]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxOS2 night build warning fixes.
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* 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 PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3652
3653 void wxApp_CleanUp() {
3654 __wxPyCleanup();
3655 }
3656
3657
3658 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3659
3660
3661
3662
3663
3664 SWIGINTERNINLINE PyObject *
3665 SWIG_FromCharPtr(const char *cptr)
3666 {
3667 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3668 }
3669
3670
3671 #if 0 // #ifdef __WXMAC__
3672
3673 // A dummy class that raises an exception if used...
3674 class wxEventLoop
3675 {
3676 public:
3677 wxEventLoop() { wxPyRaiseNotImplemented(); }
3678 int Run() { return 0; }
3679 void Exit(int rc = 0) {}
3680 bool Pending() const { return false; }
3681 bool Dispatch() { return false; }
3682 bool IsRunning() const { return false; }
3683 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3684 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3685 };
3686
3687 #else
3688
3689 #include <wx/evtloop.h>
3690
3691 #endif
3692
3693
3694
3695 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3696 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3697 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3698 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3699 wxWindowList& list = self->GetChildren();
3700 return wxPy_ConvertList(&list);
3701 }
3702 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3703 #if wxUSE_HOTKEY
3704 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3705 #else
3706 return false;
3707 #endif
3708 }
3709 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3710
3711
3712
3713 return false;
3714
3715 }
3716 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3717 return wxPyGetWinHandle(self);
3718 }
3719 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3720 self->AssociateHandle((WXWidget)handle);
3721 }
3722 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3723
3724 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3725 return wxWindow::FindWindowById(id, parent);
3726 }
3727
3728 wxWindow* wxFindWindowByName( const wxString& name,
3729 const wxWindow *parent = NULL ) {
3730 return wxWindow::FindWindowByName(name, parent);
3731 }
3732
3733 wxWindow* wxFindWindowByLabel( const wxString& label,
3734 const wxWindow *parent = NULL ) {
3735 return wxWindow::FindWindowByLabel(label, parent);
3736 }
3737
3738
3739 #ifdef __WXMSW__
3740 #include <wx/msw/private.h> // to get wxGetWindowId
3741 #endif
3742
3743
3744 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3745 #ifdef __WXMSW__
3746 WXHWND hWnd = (WXHWND)_hWnd;
3747 long id = wxGetWindowId(hWnd);
3748 wxWindow* win = new wxWindow;
3749 if (parent)
3750 parent->AddChild(win);
3751 win->SetEventHandler(win);
3752 win->SetHWND(hWnd);
3753 win->SetId(id);
3754 win->SubclassWin(hWnd);
3755 win->AdoptAttributesFromHWND();
3756 win->SetupColours();
3757 return win;
3758 #else
3759 wxPyRaiseNotImplemented();
3760 return NULL;
3761 #endif
3762 }
3763
3764
3765 PyObject* GetTopLevelWindows() {
3766 return wxPy_ConvertList(&wxTopLevelWindows);
3767 }
3768
3769
3770 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3772 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3773
3774 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3775
3776
3777 SWIGINTERNINLINE int
3778 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3779 {
3780 unsigned long v;
3781 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3782 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3783 return res;
3784 }
3785
3786 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3787 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3788 wxMenuItemList& list = self->GetMenuItems();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3792 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3793 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3794 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3795 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3796 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3797 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3798 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3799 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3800 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3801 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3802 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3803 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3804 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3805 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3806 static const wxString wxPyControlNameStr(wxControlNameStr);
3807 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3808 if (clientData) {
3809 wxPyClientData* data = new wxPyClientData(clientData);
3810 return self->Append(item, data);
3811 } else
3812 return self->Append(item);
3813 }
3814 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3815 if (clientData) {
3816 wxPyClientData* data = new wxPyClientData(clientData);
3817 return self->Insert(item, pos, data);
3818 } else
3819 return self->Insert(item, pos);
3820 }
3821 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3822 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3823 if (data) {
3824 Py_INCREF(data->m_obj);
3825 return data->m_obj;
3826 } else {
3827 Py_INCREF(Py_None);
3828 return Py_None;
3829 }
3830 }
3831 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
3832 wxPyClientData* data = new wxPyClientData(clientData);
3833 self->SetClientObject(n, data);
3834 }
3835
3836
3837 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3838 wxPyUserData* data = NULL;
3839 if ( userData ) {
3840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3841 data = new wxPyUserData(userData);
3842 wxPyEndBlockThreads(blocked);
3843 }
3844 return new wxSizerItem(window, proportion, flag, border, data);
3845 }
3846 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3847 wxPyUserData* data = NULL;
3848 if ( userData ) {
3849 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3850 data = new wxPyUserData(userData);
3851 wxPyEndBlockThreads(blocked);
3852 }
3853 return new wxSizerItem(width, height, proportion, flag, border, data);
3854 }
3855 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3856 wxPyUserData* data = NULL;
3857 if ( userData ) {
3858 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3859 data = new wxPyUserData(userData);
3860 wxPyEndBlockThreads(blocked);
3861 }
3862 return new wxSizerItem(sizer, proportion, flag, border, data);
3863 }
3864
3865 #include <float.h>
3866
3867
3868 SWIGINTERN int
3869 SWIG_AsVal_float (PyObject * obj, float *val)
3870 {
3871 double v;
3872 int res = SWIG_AsVal_double (obj, &v);
3873 if (SWIG_IsOK(res)) {
3874 if ((v < -FLT_MAX || v > FLT_MAX)) {
3875 return SWIG_OverflowError;
3876 } else {
3877 if (val) *val = static_cast< float >(v);
3878 }
3879 }
3880 return res;
3881 }
3882
3883
3884 SWIGINTERNINLINE PyObject *
3885 SWIG_From_float (float value)
3886 {
3887 return SWIG_From_double (value);
3888 }
3889
3890 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3891 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3892 if (data) {
3893 Py_INCREF(data->m_obj);
3894 return data->m_obj;
3895 } else {
3896 Py_INCREF(Py_None);
3897 return Py_None;
3898 }
3899 }
3900 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3901 wxPyUserData* data = NULL;
3902 if ( userData ) {
3903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3904 data = new wxPyUserData(userData);
3905 wxPyEndBlockThreads(blocked);
3906 }
3907 self->SetUserData(data);
3908 }
3909
3910 // Figure out the type of the sizer item
3911
3912 struct wxPySizerItemInfo {
3913 wxPySizerItemInfo()
3914 : window(NULL), sizer(NULL), gotSize(false),
3915 size(wxDefaultSize), gotPos(false), pos(-1)
3916 {}
3917
3918 wxWindow* window;
3919 wxSizer* sizer;
3920 bool gotSize;
3921 wxSize size;
3922 bool gotPos;
3923 int pos;
3924 };
3925
3926 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3927
3928 wxPySizerItemInfo info;
3929 wxSize size;
3930 wxSize* sizePtr = &size;
3931
3932 // Find out what the type of the item is
3933 // try wxWindow
3934 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3935 PyErr_Clear();
3936 info.window = NULL;
3937
3938 // try wxSizer
3939 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3940 PyErr_Clear();
3941 info.sizer = NULL;
3942
3943 // try wxSize or (w,h)
3944 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3945 info.size = *sizePtr;
3946 info.gotSize = true;
3947 }
3948
3949 // or a single int
3950 if (checkIdx && PyInt_Check(item)) {
3951 info.pos = PyInt_AsLong(item);
3952 info.gotPos = true;
3953 }
3954 }
3955 }
3956
3957 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3958 // no expected type, figure out what kind of error message to generate
3959 if ( !checkSize && !checkIdx )
3960 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3961 else if ( checkSize && !checkIdx )
3962 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3963 else if ( !checkSize && checkIdx)
3964 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3965 else
3966 // can this one happen?
3967 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3968 }
3969
3970 return info;
3971 }
3972
3973 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3974 if (!self->GetClientObject())
3975 self->SetClientObject(new wxPyOORClientData(_self));
3976 }
3977 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3978
3979 wxPyUserData* data = NULL;
3980 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3981 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3982 if ( userData && (info.window || info.sizer || info.gotSize) )
3983 data = new wxPyUserData(userData);
3984 if ( info.sizer )
3985 PyObject_SetAttrString(item,"thisown",Py_False);
3986 wxPyEndBlockThreads(blocked);
3987
3988 // Now call the real Add method if a valid item type was found
3989 if ( info.window )
3990 return self->Add(info.window, proportion, flag, border, data);
3991 else if ( info.sizer )
3992 return self->Add(info.sizer, proportion, flag, border, data);
3993 else if (info.gotSize)
3994 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3995 proportion, flag, border, data);
3996 else
3997 return NULL;
3998 }
3999 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4000
4001 wxPyUserData* data = NULL;
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4004 if ( userData && (info.window || info.sizer || info.gotSize) )
4005 data = new wxPyUserData(userData);
4006 if ( info.sizer )
4007 PyObject_SetAttrString(item,"thisown",Py_False);
4008 wxPyEndBlockThreads(blocked);
4009
4010 // Now call the real Insert method if a valid item type was found
4011 if ( info.window )
4012 return self->Insert(before, info.window, proportion, flag, border, data);
4013 else if ( info.sizer )
4014 return self->Insert(before, info.sizer, proportion, flag, border, data);
4015 else if (info.gotSize)
4016 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4017 proportion, flag, border, data);
4018 else
4019 return NULL;
4020 }
4021 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4022
4023 wxPyUserData* data = NULL;
4024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4025 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4026 if ( userData && (info.window || info.sizer || info.gotSize) )
4027 data = new wxPyUserData(userData);
4028 if ( info.sizer )
4029 PyObject_SetAttrString(item,"thisown",Py_False);
4030 wxPyEndBlockThreads(blocked);
4031
4032 // Now call the real Prepend method if a valid item type was found
4033 if ( info.window )
4034 return self->Prepend(info.window, proportion, flag, border, data);
4035 else if ( info.sizer )
4036 return self->Prepend(info.sizer, proportion, flag, border, data);
4037 else if (info.gotSize)
4038 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4039 proportion, flag, border, data);
4040 else
4041 return NULL;
4042 }
4043 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4046 wxPyEndBlockThreads(blocked);
4047 if ( info.window )
4048 return self->Remove(info.window);
4049 else if ( info.sizer )
4050 return self->Remove(info.sizer);
4051 else if ( info.gotPos )
4052 return self->Remove(info.pos);
4053 else
4054 return false;
4055 }
4056 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4059 wxPyEndBlockThreads(blocked);
4060 if ( info.window )
4061 return self->Detach(info.window);
4062 else if ( info.sizer )
4063 return self->Detach(info.sizer);
4064 else if ( info.gotPos )
4065 return self->Detach(info.pos);
4066 else
4067 return false;
4068 }
4069 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4072 wxPyEndBlockThreads(blocked);
4073 if ( info.window )
4074 return self->GetItem(info.window);
4075 else if ( info.sizer )
4076 return self->GetItem(info.sizer);
4077 else if ( info.gotPos )
4078 return self->GetItem(info.pos);
4079 else
4080 return NULL;
4081 }
4082 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4085 wxPyEndBlockThreads(blocked);
4086 if ( info.window )
4087 self->SetItemMinSize(info.window, size);
4088 else if ( info.sizer )
4089 self->SetItemMinSize(info.sizer, size);
4090 else if ( info.gotPos )
4091 self->SetItemMinSize(info.pos, size);
4092 }
4093 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4094 wxSizerItemList& list = self->GetChildren();
4095 return wxPy_ConvertList(&list);
4096 }
4097 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4098 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4099 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4100 wxPyEndBlockThreads(blocked);
4101 if ( info.window )
4102 return self->Show(info.window, show, recursive);
4103 else if ( info.sizer )
4104 return self->Show(info.sizer, show, recursive);
4105 else if ( info.gotPos )
4106 return self->Show(info.pos, show);
4107 else
4108 return false;
4109 }
4110 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4113 wxPyEndBlockThreads(blocked);
4114 if ( info.window )
4115 return self->IsShown(info.window);
4116 else if ( info.sizer )
4117 return self->IsShown(info.sizer);
4118 else if ( info.gotPos )
4119 return self->IsShown(info.pos);
4120 else
4121 return false;
4122 }
4123
4124 // See pyclasses.h
4125 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4126 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4127 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4128
4129
4130
4131
4132 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4133 {
4134 if (source == Py_None) {
4135 **obj = wxGBPosition(-1,-1);
4136 return true;
4137 }
4138 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4139 }
4140
4141 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4142 {
4143 if (source == Py_None) {
4144 **obj = wxGBSpan(-1,-1);
4145 return true;
4146 }
4147 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4148 }
4149
4150
4151 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4152 self->SetRow(row);
4153 self->SetCol(col);
4154 }
4155 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4157 PyObject* tup = PyTuple_New(2);
4158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4160 wxPyEndBlockThreads(blocked);
4161 return tup;
4162 }
4163 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4164 self->SetRowspan(rowspan);
4165 self->SetColspan(colspan);
4166 }
4167 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 PyObject* tup = PyTuple_New(2);
4170 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4171 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4172 wxPyEndBlockThreads(blocked);
4173 return tup;
4174 }
4175 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4176 wxPyUserData* data = NULL;
4177 if ( userData ) {
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 data = new wxPyUserData(userData);
4180 wxPyEndBlockThreads(blocked);
4181 }
4182 return new wxGBSizerItem(window, pos, span, flag, border, data);
4183 }
4184 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4185 wxPyUserData* data = NULL;
4186 if ( userData ) {
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 data = new wxPyUserData(userData);
4189 wxPyEndBlockThreads(blocked);
4190 }
4191 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4192 }
4193 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4194 wxPyUserData* data = NULL;
4195 if ( userData ) {
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 data = new wxPyUserData(userData);
4198 wxPyEndBlockThreads(blocked);
4199 }
4200 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4201 }
4202 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4203 int row, col;
4204 self->GetEndPos(row, col);
4205 return wxGBPosition(row, col);
4206 }
4207 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4208
4209 wxPyUserData* data = NULL;
4210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4212 if ( userData && (info.window || info.sizer || info.gotSize) )
4213 data = new wxPyUserData(userData);
4214 if ( info.sizer )
4215 PyObject_SetAttrString(item,"thisown",Py_False);
4216 wxPyEndBlockThreads(blocked);
4217
4218 // Now call the real Add method if a valid item type was found
4219 if ( info.window )
4220 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4221 else if ( info.sizer )
4222 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4223 else if (info.gotSize)
4224 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4225 pos, span, flag, border, data);
4226 return NULL;
4227 }
4228
4229
4230 #ifdef __cplusplus
4231 extern "C" {
4232 #endif
4233 SWIGINTERN int EmptyString_set(PyObject *) {
4234 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4235 return 1;
4236 }
4237
4238
4239 SWIGINTERN PyObject *EmptyString_get(void) {
4240 PyObject *pyobj = 0;
4241
4242 {
4243 #if wxUSE_UNICODE
4244 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4245 #else
4246 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4247 #endif
4248 }
4249 return pyobj;
4250 }
4251
4252
4253 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254 PyObject *resultobj = 0;
4255 wxObject *arg1 = (wxObject *) 0 ;
4256 wxString result;
4257 void *argp1 = 0 ;
4258 int res1 = 0 ;
4259 PyObject *swig_obj[1] ;
4260
4261 if (!args) SWIG_fail;
4262 swig_obj[0] = args;
4263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4264 if (!SWIG_IsOK(res1)) {
4265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4266 }
4267 arg1 = reinterpret_cast< wxObject * >(argp1);
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = wxObject_GetClassName(arg1);
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 {
4275 #if wxUSE_UNICODE
4276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4277 #else
4278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4279 #endif
4280 }
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4288 PyObject *resultobj = 0;
4289 wxObject *arg1 = (wxObject *) 0 ;
4290 void *argp1 = 0 ;
4291 int res1 = 0 ;
4292 PyObject *swig_obj[1] ;
4293
4294 if (!args) SWIG_fail;
4295 swig_obj[0] = args;
4296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4299 }
4300 arg1 = reinterpret_cast< wxObject * >(argp1);
4301 {
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 wxObject_Destroy(arg1);
4304 wxPyEndAllowThreads(__tstate);
4305 if (PyErr_Occurred()) SWIG_fail;
4306 }
4307 resultobj = SWIG_Py_Void();
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
4314 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *obj;
4316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4317 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4318 return SWIG_Py_Void();
4319 }
4320
4321 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4322 PyObject *resultobj = 0;
4323 wxSize *arg1 = (wxSize *) 0 ;
4324 int arg2 ;
4325 void *argp1 = 0 ;
4326 int res1 = 0 ;
4327 int val2 ;
4328 int ecode2 = 0 ;
4329 PyObject *swig_obj[2] ;
4330
4331 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4333 if (!SWIG_IsOK(res1)) {
4334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4335 }
4336 arg1 = reinterpret_cast< wxSize * >(argp1);
4337 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4338 if (!SWIG_IsOK(ecode2)) {
4339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4340 }
4341 arg2 = static_cast< int >(val2);
4342 if (arg1) (arg1)->x = arg2;
4343
4344 resultobj = SWIG_Py_Void();
4345 return resultobj;
4346 fail:
4347 return NULL;
4348 }
4349
4350
4351 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4352 PyObject *resultobj = 0;
4353 wxSize *arg1 = (wxSize *) 0 ;
4354 int result;
4355 void *argp1 = 0 ;
4356 int res1 = 0 ;
4357 PyObject *swig_obj[1] ;
4358
4359 if (!args) SWIG_fail;
4360 swig_obj[0] = args;
4361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4362 if (!SWIG_IsOK(res1)) {
4363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4364 }
4365 arg1 = reinterpret_cast< wxSize * >(argp1);
4366 result = (int) ((arg1)->x);
4367 resultobj = SWIG_From_int(static_cast< int >(result));
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4375 PyObject *resultobj = 0;
4376 wxSize *arg1 = (wxSize *) 0 ;
4377 int arg2 ;
4378 void *argp1 = 0 ;
4379 int res1 = 0 ;
4380 int val2 ;
4381 int ecode2 = 0 ;
4382 PyObject *swig_obj[2] ;
4383
4384 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4386 if (!SWIG_IsOK(res1)) {
4387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4388 }
4389 arg1 = reinterpret_cast< wxSize * >(argp1);
4390 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4391 if (!SWIG_IsOK(ecode2)) {
4392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4393 }
4394 arg2 = static_cast< int >(val2);
4395 if (arg1) (arg1)->y = arg2;
4396
4397 resultobj = SWIG_Py_Void();
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4405 PyObject *resultobj = 0;
4406 wxSize *arg1 = (wxSize *) 0 ;
4407 int result;
4408 void *argp1 = 0 ;
4409 int res1 = 0 ;
4410 PyObject *swig_obj[1] ;
4411
4412 if (!args) SWIG_fail;
4413 swig_obj[0] = args;
4414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4415 if (!SWIG_IsOK(res1)) {
4416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4417 }
4418 arg1 = reinterpret_cast< wxSize * >(argp1);
4419 result = (int) ((arg1)->y);
4420 resultobj = SWIG_From_int(static_cast< int >(result));
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 int arg1 = (int) 0 ;
4430 int arg2 = (int) 0 ;
4431 wxSize *result = 0 ;
4432 int val1 ;
4433 int ecode1 = 0 ;
4434 int val2 ;
4435 int ecode2 = 0 ;
4436 PyObject * obj0 = 0 ;
4437 PyObject * obj1 = 0 ;
4438 char * kwnames[] = {
4439 (char *) "w",(char *) "h", NULL
4440 };
4441
4442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4443 if (obj0) {
4444 ecode1 = SWIG_AsVal_int(obj0, &val1);
4445 if (!SWIG_IsOK(ecode1)) {
4446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4447 }
4448 arg1 = static_cast< int >(val1);
4449 }
4450 if (obj1) {
4451 ecode2 = SWIG_AsVal_int(obj1, &val2);
4452 if (!SWIG_IsOK(ecode2)) {
4453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4454 }
4455 arg2 = static_cast< int >(val2);
4456 }
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 result = (wxSize *)new wxSize(arg1,arg2);
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4464 return resultobj;
4465 fail:
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4471 PyObject *resultobj = 0;
4472 wxSize *arg1 = (wxSize *) 0 ;
4473 void *argp1 = 0 ;
4474 int res1 = 0 ;
4475 PyObject *swig_obj[1] ;
4476
4477 if (!args) SWIG_fail;
4478 swig_obj[0] = args;
4479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4480 if (!SWIG_IsOK(res1)) {
4481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4482 }
4483 arg1 = reinterpret_cast< wxSize * >(argp1);
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 delete arg1;
4487
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 resultobj = SWIG_Py_Void();
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj = 0;
4500 wxSize *arg1 = (wxSize *) 0 ;
4501 wxSize *arg2 = 0 ;
4502 bool result;
4503 void *argp1 = 0 ;
4504 int res1 = 0 ;
4505 wxSize temp2 ;
4506 PyObject * obj0 = 0 ;
4507 PyObject * obj1 = 0 ;
4508 char * kwnames[] = {
4509 (char *) "self",(char *) "sz", NULL
4510 };
4511
4512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4514 if (!SWIG_IsOK(res1)) {
4515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4516 }
4517 arg1 = reinterpret_cast< wxSize * >(argp1);
4518 {
4519 arg2 = &temp2;
4520 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4521 }
4522 {
4523 PyThreadState* __tstate = wxPyBeginAllowThreads();
4524 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4525 wxPyEndAllowThreads(__tstate);
4526 if (PyErr_Occurred()) SWIG_fail;
4527 }
4528 {
4529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4530 }
4531 return resultobj;
4532 fail:
4533 return NULL;
4534 }
4535
4536
4537 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4538 PyObject *resultobj = 0;
4539 wxSize *arg1 = (wxSize *) 0 ;
4540 wxSize *arg2 = 0 ;
4541 bool result;
4542 void *argp1 = 0 ;
4543 int res1 = 0 ;
4544 wxSize temp2 ;
4545 PyObject * obj0 = 0 ;
4546 PyObject * obj1 = 0 ;
4547 char * kwnames[] = {
4548 (char *) "self",(char *) "sz", NULL
4549 };
4550
4551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4553 if (!SWIG_IsOK(res1)) {
4554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4555 }
4556 arg1 = reinterpret_cast< wxSize * >(argp1);
4557 {
4558 arg2 = &temp2;
4559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4569 }
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj = 0;
4578 wxSize *arg1 = (wxSize *) 0 ;
4579 wxSize *arg2 = 0 ;
4580 wxSize result;
4581 void *argp1 = 0 ;
4582 int res1 = 0 ;
4583 wxSize temp2 ;
4584 PyObject * obj0 = 0 ;
4585 PyObject * obj1 = 0 ;
4586 char * kwnames[] = {
4587 (char *) "self",(char *) "sz", NULL
4588 };
4589
4590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4592 if (!SWIG_IsOK(res1)) {
4593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4594 }
4595 arg1 = reinterpret_cast< wxSize * >(argp1);
4596 {
4597 arg2 = &temp2;
4598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4599 }
4600 {
4601 PyThreadState* __tstate = wxPyBeginAllowThreads();
4602 result = (arg1)->operator +((wxSize const &)*arg2);
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4607 return resultobj;
4608 fail:
4609 return NULL;
4610 }
4611
4612
4613 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4614 PyObject *resultobj = 0;
4615 wxSize *arg1 = (wxSize *) 0 ;
4616 wxSize *arg2 = 0 ;
4617 wxSize result;
4618 void *argp1 = 0 ;
4619 int res1 = 0 ;
4620 wxSize temp2 ;
4621 PyObject * obj0 = 0 ;
4622 PyObject * obj1 = 0 ;
4623 char * kwnames[] = {
4624 (char *) "self",(char *) "sz", NULL
4625 };
4626
4627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4629 if (!SWIG_IsOK(res1)) {
4630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4631 }
4632 arg1 = reinterpret_cast< wxSize * >(argp1);
4633 {
4634 arg2 = &temp2;
4635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4636 }
4637 {
4638 PyThreadState* __tstate = wxPyBeginAllowThreads();
4639 result = (arg1)->operator -((wxSize const &)*arg2);
4640 wxPyEndAllowThreads(__tstate);
4641 if (PyErr_Occurred()) SWIG_fail;
4642 }
4643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4644 return resultobj;
4645 fail:
4646 return NULL;
4647 }
4648
4649
4650 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj = 0;
4652 wxSize *arg1 = (wxSize *) 0 ;
4653 wxSize *arg2 = 0 ;
4654 void *argp1 = 0 ;
4655 int res1 = 0 ;
4656 wxSize temp2 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 char * kwnames[] = {
4660 (char *) "self",(char *) "sz", NULL
4661 };
4662
4663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4665 if (!SWIG_IsOK(res1)) {
4666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4667 }
4668 arg1 = reinterpret_cast< wxSize * >(argp1);
4669 {
4670 arg2 = &temp2;
4671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4672 }
4673 {
4674 PyThreadState* __tstate = wxPyBeginAllowThreads();
4675 (arg1)->IncTo((wxSize const &)*arg2);
4676 wxPyEndAllowThreads(__tstate);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 resultobj = SWIG_Py_Void();
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
4686 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4687 PyObject *resultobj = 0;
4688 wxSize *arg1 = (wxSize *) 0 ;
4689 wxSize *arg2 = 0 ;
4690 void *argp1 = 0 ;
4691 int res1 = 0 ;
4692 wxSize temp2 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 char * kwnames[] = {
4696 (char *) "self",(char *) "sz", NULL
4697 };
4698
4699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4701 if (!SWIG_IsOK(res1)) {
4702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4703 }
4704 arg1 = reinterpret_cast< wxSize * >(argp1);
4705 {
4706 arg2 = &temp2;
4707 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4708 }
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 (arg1)->DecTo((wxSize const &)*arg2);
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_Py_Void();
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 wxSize *arg1 = (wxSize *) 0 ;
4725 int arg2 ;
4726 int arg3 ;
4727 void *argp1 = 0 ;
4728 int res1 = 0 ;
4729 int val2 ;
4730 int ecode2 = 0 ;
4731 int val3 ;
4732 int ecode3 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 PyObject * obj2 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "w",(char *) "h", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 ecode2 = SWIG_AsVal_int(obj1, &val2);
4747 if (!SWIG_IsOK(ecode2)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4749 }
4750 arg2 = static_cast< int >(val2);
4751 ecode3 = SWIG_AsVal_int(obj2, &val3);
4752 if (!SWIG_IsOK(ecode3)) {
4753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4754 }
4755 arg3 = static_cast< int >(val3);
4756 {
4757 PyThreadState* __tstate = wxPyBeginAllowThreads();
4758 (arg1)->Set(arg2,arg3);
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 resultobj = SWIG_Py_Void();
4763 return resultobj;
4764 fail:
4765 return NULL;
4766 }
4767
4768
4769 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4770 PyObject *resultobj = 0;
4771 wxSize *arg1 = (wxSize *) 0 ;
4772 int arg2 ;
4773 void *argp1 = 0 ;
4774 int res1 = 0 ;
4775 int val2 ;
4776 int ecode2 = 0 ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 char * kwnames[] = {
4780 (char *) "self",(char *) "w", NULL
4781 };
4782
4783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4785 if (!SWIG_IsOK(res1)) {
4786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4787 }
4788 arg1 = reinterpret_cast< wxSize * >(argp1);
4789 ecode2 = SWIG_AsVal_int(obj1, &val2);
4790 if (!SWIG_IsOK(ecode2)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4792 }
4793 arg2 = static_cast< int >(val2);
4794 {
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 (arg1)->SetWidth(arg2);
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 resultobj = SWIG_Py_Void();
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = 0;
4809 wxSize *arg1 = (wxSize *) 0 ;
4810 int arg2 ;
4811 void *argp1 = 0 ;
4812 int res1 = 0 ;
4813 int val2 ;
4814 int ecode2 = 0 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char * kwnames[] = {
4818 (char *) "self",(char *) "h", NULL
4819 };
4820
4821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 ecode2 = SWIG_AsVal_int(obj1, &val2);
4828 if (!SWIG_IsOK(ecode2)) {
4829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4830 }
4831 arg2 = static_cast< int >(val2);
4832 {
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 (arg1)->SetHeight(arg2);
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847 wxSize *arg1 = (wxSize *) 0 ;
4848 int result;
4849 void *argp1 = 0 ;
4850 int res1 = 0 ;
4851 PyObject *swig_obj[1] ;
4852
4853 if (!args) SWIG_fail;
4854 swig_obj[0] = args;
4855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4856 if (!SWIG_IsOK(res1)) {
4857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4858 }
4859 arg1 = reinterpret_cast< wxSize * >(argp1);
4860 {
4861 PyThreadState* __tstate = wxPyBeginAllowThreads();
4862 result = (int)((wxSize const *)arg1)->GetWidth();
4863 wxPyEndAllowThreads(__tstate);
4864 if (PyErr_Occurred()) SWIG_fail;
4865 }
4866 resultobj = SWIG_From_int(static_cast< int >(result));
4867 return resultobj;
4868 fail:
4869 return NULL;
4870 }
4871
4872
4873 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4874 PyObject *resultobj = 0;
4875 wxSize *arg1 = (wxSize *) 0 ;
4876 int result;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 PyObject *swig_obj[1] ;
4880
4881 if (!args) SWIG_fail;
4882 swig_obj[0] = args;
4883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4884 if (!SWIG_IsOK(res1)) {
4885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4886 }
4887 arg1 = reinterpret_cast< wxSize * >(argp1);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 result = (int)((wxSize const *)arg1)->GetHeight();
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_From_int(static_cast< int >(result));
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 bool result;
4905 void *argp1 = 0 ;
4906 int res1 = 0 ;
4907 PyObject *swig_obj[1] ;
4908
4909 if (!args) SWIG_fail;
4910 swig_obj[0] = args;
4911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4912 if (!SWIG_IsOK(res1)) {
4913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4914 }
4915 arg1 = reinterpret_cast< wxSize * >(argp1);
4916 {
4917 PyThreadState* __tstate = wxPyBeginAllowThreads();
4918 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 {
4923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4924 }
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxSize *arg1 = (wxSize *) 0 ;
4934 wxSize *arg2 = 0 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 wxSize temp2 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "size", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4948 }
4949 arg1 = reinterpret_cast< wxSize * >(argp1);
4950 {
4951 arg2 = &temp2;
4952 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4953 }
4954 {
4955 PyThreadState* __tstate = wxPyBeginAllowThreads();
4956 (arg1)->SetDefaults((wxSize const &)*arg2);
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_Py_Void();
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4968 PyObject *resultobj = 0;
4969 wxSize *arg1 = (wxSize *) 0 ;
4970 PyObject *result = 0 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 PyObject *swig_obj[1] ;
4974
4975 if (!args) SWIG_fail;
4976 swig_obj[0] = args;
4977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4978 if (!SWIG_IsOK(res1)) {
4979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4980 }
4981 arg1 = reinterpret_cast< wxSize * >(argp1);
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 result = (PyObject *)wxSize_Get(arg1);
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = result;
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4996 PyObject *obj;
4997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4998 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
4999 return SWIG_Py_Void();
5000 }
5001
5002 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5003 return SWIG_Python_InitShadowInstance(args);
5004 }
5005
5006 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5007 PyObject *resultobj = 0;
5008 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5009 double arg2 ;
5010 void *argp1 = 0 ;
5011 int res1 = 0 ;
5012 double val2 ;
5013 int ecode2 = 0 ;
5014 PyObject *swig_obj[2] ;
5015
5016 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5020 }
5021 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5022 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5025 }
5026 arg2 = static_cast< double >(val2);
5027 if (arg1) (arg1)->x = arg2;
5028
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5037 PyObject *resultobj = 0;
5038 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5039 double result;
5040 void *argp1 = 0 ;
5041 int res1 = 0 ;
5042 PyObject *swig_obj[1] ;
5043
5044 if (!args) SWIG_fail;
5045 swig_obj[0] = args;
5046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5047 if (!SWIG_IsOK(res1)) {
5048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5049 }
5050 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5051 result = (double) ((arg1)->x);
5052 resultobj = SWIG_From_double(static_cast< double >(result));
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060 PyObject *resultobj = 0;
5061 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5062 double arg2 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 double val2 ;
5066 int ecode2 = 0 ;
5067 PyObject *swig_obj[2] ;
5068
5069 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5071 if (!SWIG_IsOK(res1)) {
5072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5073 }
5074 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5075 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5076 if (!SWIG_IsOK(ecode2)) {
5077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5078 }
5079 arg2 = static_cast< double >(val2);
5080 if (arg1) (arg1)->y = arg2;
5081
5082 resultobj = SWIG_Py_Void();
5083 return resultobj;
5084 fail:
5085 return NULL;
5086 }
5087
5088
5089 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5090 PyObject *resultobj = 0;
5091 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5092 double result;
5093 void *argp1 = 0 ;
5094 int res1 = 0 ;
5095 PyObject *swig_obj[1] ;
5096
5097 if (!args) SWIG_fail;
5098 swig_obj[0] = args;
5099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5102 }
5103 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5104 result = (double) ((arg1)->y);
5105 resultobj = SWIG_From_double(static_cast< double >(result));
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj = 0;
5114 double arg1 = (double) 0.0 ;
5115 double arg2 = (double) 0.0 ;
5116 wxRealPoint *result = 0 ;
5117 double val1 ;
5118 int ecode1 = 0 ;
5119 double val2 ;
5120 int ecode2 = 0 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "x",(char *) "y", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5128 if (obj0) {
5129 ecode1 = SWIG_AsVal_double(obj0, &val1);
5130 if (!SWIG_IsOK(ecode1)) {
5131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5132 }
5133 arg1 = static_cast< double >(val1);
5134 }
5135 if (obj1) {
5136 ecode2 = SWIG_AsVal_double(obj1, &val2);
5137 if (!SWIG_IsOK(ecode2)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5139 }
5140 arg2 = static_cast< double >(val2);
5141 }
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5156 PyObject *resultobj = 0;
5157 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5158 void *argp1 = 0 ;
5159 int res1 = 0 ;
5160 PyObject *swig_obj[1] ;
5161
5162 if (!args) SWIG_fail;
5163 swig_obj[0] = args;
5164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5165 if (!SWIG_IsOK(res1)) {
5166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5167 }
5168 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 delete arg1;
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 resultobj = SWIG_Py_Void();
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj = 0;
5185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5186 wxRealPoint *arg2 = 0 ;
5187 bool result;
5188 void *argp1 = 0 ;
5189 int res1 = 0 ;
5190 wxRealPoint temp2 ;
5191 PyObject * obj0 = 0 ;
5192 PyObject * obj1 = 0 ;
5193 char * kwnames[] = {
5194 (char *) "self",(char *) "pt", NULL
5195 };
5196
5197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5199 if (!SWIG_IsOK(res1)) {
5200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5201 }
5202 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5203 {
5204 arg2 = &temp2;
5205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5206 }
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 {
5214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5225 wxRealPoint *arg2 = 0 ;
5226 bool result;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 wxRealPoint temp2 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 char * kwnames[] = {
5233 (char *) "self",(char *) "pt", NULL
5234 };
5235
5236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5238 if (!SWIG_IsOK(res1)) {
5239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5240 }
5241 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5242 {
5243 arg2 = &temp2;
5244 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5245 }
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 {
5253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5254 }
5255 return resultobj;
5256 fail:
5257 return NULL;
5258 }
5259
5260
5261 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5262 PyObject *resultobj = 0;
5263 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5264 wxRealPoint *arg2 = 0 ;
5265 wxRealPoint result;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 wxRealPoint temp2 ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "pt", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5279 }
5280 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5281 {
5282 arg2 = &temp2;
5283 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5284 }
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj = 0;
5300 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5301 wxRealPoint *arg2 = 0 ;
5302 wxRealPoint result;
5303 void *argp1 = 0 ;
5304 int res1 = 0 ;
5305 wxRealPoint temp2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char * kwnames[] = {
5309 (char *) "self",(char *) "pt", NULL
5310 };
5311
5312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5314 if (!SWIG_IsOK(res1)) {
5315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5316 }
5317 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5318 {
5319 arg2 = &temp2;
5320 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5321 }
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj = 0;
5337 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5338 double arg2 ;
5339 double arg3 ;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 double val2 ;
5343 int ecode2 = 0 ;
5344 double val3 ;
5345 int ecode3 = 0 ;
5346 PyObject * obj0 = 0 ;
5347 PyObject * obj1 = 0 ;
5348 PyObject * obj2 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "self",(char *) "x",(char *) "y", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5355 if (!SWIG_IsOK(res1)) {
5356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5357 }
5358 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5359 ecode2 = SWIG_AsVal_double(obj1, &val2);
5360 if (!SWIG_IsOK(ecode2)) {
5361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5362 }
5363 arg2 = static_cast< double >(val2);
5364 ecode3 = SWIG_AsVal_double(obj2, &val3);
5365 if (!SWIG_IsOK(ecode3)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5367 }
5368 arg3 = static_cast< double >(val3);
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 wxRealPoint_Set(arg1,arg2,arg3);
5372 wxPyEndAllowThreads(__tstate);
5373 if (PyErr_Occurred()) SWIG_fail;
5374 }
5375 resultobj = SWIG_Py_Void();
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5383 PyObject *resultobj = 0;
5384 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5385 PyObject *result = 0 ;
5386 void *argp1 = 0 ;
5387 int res1 = 0 ;
5388 PyObject *swig_obj[1] ;
5389
5390 if (!args) SWIG_fail;
5391 swig_obj[0] = args;
5392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = (PyObject *)wxRealPoint_Get(arg1);
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 resultobj = result;
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411 PyObject *obj;
5412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5413 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5414 return SWIG_Py_Void();
5415 }
5416
5417 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 return SWIG_Python_InitShadowInstance(args);
5419 }
5420
5421 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5422 PyObject *resultobj = 0;
5423 wxPoint *arg1 = (wxPoint *) 0 ;
5424 int arg2 ;
5425 void *argp1 = 0 ;
5426 int res1 = 0 ;
5427 int val2 ;
5428 int ecode2 = 0 ;
5429 PyObject *swig_obj[2] ;
5430
5431 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5433 if (!SWIG_IsOK(res1)) {
5434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5435 }
5436 arg1 = reinterpret_cast< wxPoint * >(argp1);
5437 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5438 if (!SWIG_IsOK(ecode2)) {
5439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5440 }
5441 arg2 = static_cast< int >(val2);
5442 if (arg1) (arg1)->x = arg2;
5443
5444 resultobj = SWIG_Py_Void();
5445 return resultobj;
5446 fail:
5447 return NULL;
5448 }
5449
5450
5451 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5452 PyObject *resultobj = 0;
5453 wxPoint *arg1 = (wxPoint *) 0 ;
5454 int result;
5455 void *argp1 = 0 ;
5456 int res1 = 0 ;
5457 PyObject *swig_obj[1] ;
5458
5459 if (!args) SWIG_fail;
5460 swig_obj[0] = args;
5461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5462 if (!SWIG_IsOK(res1)) {
5463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5464 }
5465 arg1 = reinterpret_cast< wxPoint * >(argp1);
5466 result = (int) ((arg1)->x);
5467 resultobj = SWIG_From_int(static_cast< int >(result));
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5475 PyObject *resultobj = 0;
5476 wxPoint *arg1 = (wxPoint *) 0 ;
5477 int arg2 ;
5478 void *argp1 = 0 ;
5479 int res1 = 0 ;
5480 int val2 ;
5481 int ecode2 = 0 ;
5482 PyObject *swig_obj[2] ;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5486 if (!SWIG_IsOK(res1)) {
5487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5488 }
5489 arg1 = reinterpret_cast< wxPoint * >(argp1);
5490 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5491 if (!SWIG_IsOK(ecode2)) {
5492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5493 }
5494 arg2 = static_cast< int >(val2);
5495 if (arg1) (arg1)->y = arg2;
5496
5497 resultobj = SWIG_Py_Void();
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxPoint *arg1 = (wxPoint *) 0 ;
5507 int result;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 PyObject *swig_obj[1] ;
5511
5512 if (!args) SWIG_fail;
5513 swig_obj[0] = args;
5514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5515 if (!SWIG_IsOK(res1)) {
5516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5517 }
5518 arg1 = reinterpret_cast< wxPoint * >(argp1);
5519 result = (int) ((arg1)->y);
5520 resultobj = SWIG_From_int(static_cast< int >(result));
5521 return resultobj;
5522 fail:
5523 return NULL;
5524 }
5525
5526
5527 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5528 PyObject *resultobj = 0;
5529 int arg1 = (int) 0 ;
5530 int arg2 = (int) 0 ;
5531 wxPoint *result = 0 ;
5532 int val1 ;
5533 int ecode1 = 0 ;
5534 int val2 ;
5535 int ecode2 = 0 ;
5536 PyObject * obj0 = 0 ;
5537 PyObject * obj1 = 0 ;
5538 char * kwnames[] = {
5539 (char *) "x",(char *) "y", NULL
5540 };
5541
5542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5543 if (obj0) {
5544 ecode1 = SWIG_AsVal_int(obj0, &val1);
5545 if (!SWIG_IsOK(ecode1)) {
5546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5547 }
5548 arg1 = static_cast< int >(val1);
5549 }
5550 if (obj1) {
5551 ecode2 = SWIG_AsVal_int(obj1, &val2);
5552 if (!SWIG_IsOK(ecode2)) {
5553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5554 }
5555 arg2 = static_cast< int >(val2);
5556 }
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 result = (wxPoint *)new wxPoint(arg1,arg2);
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxPoint *arg1 = (wxPoint *) 0 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 PyObject *swig_obj[1] ;
5576
5577 if (!args) SWIG_fail;
5578 swig_obj[0] = args;
5579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5580 if (!SWIG_IsOK(res1)) {
5581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5582 }
5583 arg1 = reinterpret_cast< wxPoint * >(argp1);
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 delete arg1;
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 resultobj = SWIG_Py_Void();
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 wxPoint *arg1 = (wxPoint *) 0 ;
5601 wxPoint *arg2 = 0 ;
5602 bool result;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 wxPoint temp2 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char * kwnames[] = {
5609 (char *) "self",(char *) "pt", NULL
5610 };
5611
5612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5614 if (!SWIG_IsOK(res1)) {
5615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5616 }
5617 arg1 = reinterpret_cast< wxPoint * >(argp1);
5618 {
5619 arg2 = &temp2;
5620 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5621 }
5622 {
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 {
5629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5630 }
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj = 0;
5639 wxPoint *arg1 = (wxPoint *) 0 ;
5640 wxPoint *arg2 = 0 ;
5641 bool result;
5642 void *argp1 = 0 ;
5643 int res1 = 0 ;
5644 wxPoint temp2 ;
5645 PyObject * obj0 = 0 ;
5646 PyObject * obj1 = 0 ;
5647 char * kwnames[] = {
5648 (char *) "self",(char *) "pt", NULL
5649 };
5650
5651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 {
5658 arg2 = &temp2;
5659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 {
5668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5669 }
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj = 0;
5678 wxPoint *arg1 = (wxPoint *) 0 ;
5679 wxPoint *arg2 = 0 ;
5680 wxPoint result;
5681 void *argp1 = 0 ;
5682 int res1 = 0 ;
5683 wxPoint temp2 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 char * kwnames[] = {
5687 (char *) "self",(char *) "pt", NULL
5688 };
5689
5690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5692 if (!SWIG_IsOK(res1)) {
5693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5694 }
5695 arg1 = reinterpret_cast< wxPoint * >(argp1);
5696 {
5697 arg2 = &temp2;
5698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5699 }
5700 {
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 result = (arg1)->operator +((wxPoint const &)*arg2);
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj = 0;
5715 wxPoint *arg1 = (wxPoint *) 0 ;
5716 wxPoint *arg2 = 0 ;
5717 wxPoint result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 wxPoint temp2 ;
5721 PyObject * obj0 = 0 ;
5722 PyObject * obj1 = 0 ;
5723 char * kwnames[] = {
5724 (char *) "self",(char *) "pt", NULL
5725 };
5726
5727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5729 if (!SWIG_IsOK(res1)) {
5730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5731 }
5732 arg1 = reinterpret_cast< wxPoint * >(argp1);
5733 {
5734 arg2 = &temp2;
5735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (arg1)->operator -((wxPoint const &)*arg2);
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5751 PyObject *resultobj = 0;
5752 wxPoint *arg1 = (wxPoint *) 0 ;
5753 wxPoint *arg2 = 0 ;
5754 wxPoint *result = 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 wxPoint temp2 ;
5758 PyObject * obj0 = 0 ;
5759 PyObject * obj1 = 0 ;
5760 char * kwnames[] = {
5761 (char *) "self",(char *) "pt", NULL
5762 };
5763
5764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5766 if (!SWIG_IsOK(res1)) {
5767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5768 }
5769 arg1 = reinterpret_cast< wxPoint * >(argp1);
5770 {
5771 arg2 = &temp2;
5772 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5773 }
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 {
5777 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5778 result = (wxPoint *) &_result_ref;
5779 }
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 wxPoint *arg1 = (wxPoint *) 0 ;
5793 wxPoint *arg2 = 0 ;
5794 wxPoint *result = 0 ;
5795 void *argp1 = 0 ;
5796 int res1 = 0 ;
5797 wxPoint temp2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char * kwnames[] = {
5801 (char *) "self",(char *) "pt", NULL
5802 };
5803
5804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5806 if (!SWIG_IsOK(res1)) {
5807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5808 }
5809 arg1 = reinterpret_cast< wxPoint * >(argp1);
5810 {
5811 arg2 = &temp2;
5812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5813 }
5814 {
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 {
5817 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5818 result = (wxPoint *) &_result_ref;
5819 }
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = 0;
5832 wxPoint *arg1 = (wxPoint *) 0 ;
5833 long arg2 ;
5834 long arg3 ;
5835 void *argp1 = 0 ;
5836 int res1 = 0 ;
5837 long val2 ;
5838 int ecode2 = 0 ;
5839 long val3 ;
5840 int ecode3 = 0 ;
5841 PyObject * obj0 = 0 ;
5842 PyObject * obj1 = 0 ;
5843 PyObject * obj2 = 0 ;
5844 char * kwnames[] = {
5845 (char *) "self",(char *) "x",(char *) "y", NULL
5846 };
5847
5848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5850 if (!SWIG_IsOK(res1)) {
5851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5852 }
5853 arg1 = reinterpret_cast< wxPoint * >(argp1);
5854 ecode2 = SWIG_AsVal_long(obj1, &val2);
5855 if (!SWIG_IsOK(ecode2)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5857 }
5858 arg2 = static_cast< long >(val2);
5859 ecode3 = SWIG_AsVal_long(obj2, &val3);
5860 if (!SWIG_IsOK(ecode3)) {
5861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5862 }
5863 arg3 = static_cast< long >(val3);
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 wxPoint_Set(arg1,arg2,arg3);
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_Py_Void();
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5878 PyObject *resultobj = 0;
5879 wxPoint *arg1 = (wxPoint *) 0 ;
5880 PyObject *result = 0 ;
5881 void *argp1 = 0 ;
5882 int res1 = 0 ;
5883 PyObject *swig_obj[1] ;
5884
5885 if (!args) SWIG_fail;
5886 swig_obj[0] = args;
5887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5888 if (!SWIG_IsOK(res1)) {
5889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5890 }
5891 arg1 = reinterpret_cast< wxPoint * >(argp1);
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (PyObject *)wxPoint_Get(arg1);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = result;
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5906 PyObject *obj;
5907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5908 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5909 return SWIG_Py_Void();
5910 }
5911
5912 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5913 return SWIG_Python_InitShadowInstance(args);
5914 }
5915
5916 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj = 0;
5918 int arg1 = (int) 0 ;
5919 int arg2 = (int) 0 ;
5920 int arg3 = (int) 0 ;
5921 int arg4 = (int) 0 ;
5922 wxRect *result = 0 ;
5923 int val1 ;
5924 int ecode1 = 0 ;
5925 int val2 ;
5926 int ecode2 = 0 ;
5927 int val3 ;
5928 int ecode3 = 0 ;
5929 int val4 ;
5930 int ecode4 = 0 ;
5931 PyObject * obj0 = 0 ;
5932 PyObject * obj1 = 0 ;
5933 PyObject * obj2 = 0 ;
5934 PyObject * obj3 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5940 if (obj0) {
5941 ecode1 = SWIG_AsVal_int(obj0, &val1);
5942 if (!SWIG_IsOK(ecode1)) {
5943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5944 }
5945 arg1 = static_cast< int >(val1);
5946 }
5947 if (obj1) {
5948 ecode2 = SWIG_AsVal_int(obj1, &val2);
5949 if (!SWIG_IsOK(ecode2)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5951 }
5952 arg2 = static_cast< int >(val2);
5953 }
5954 if (obj2) {
5955 ecode3 = SWIG_AsVal_int(obj2, &val3);
5956 if (!SWIG_IsOK(ecode3)) {
5957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5958 }
5959 arg3 = static_cast< int >(val3);
5960 }
5961 if (obj3) {
5962 ecode4 = SWIG_AsVal_int(obj3, &val4);
5963 if (!SWIG_IsOK(ecode4)) {
5964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5965 }
5966 arg4 = static_cast< int >(val4);
5967 }
5968 {
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = 0 ;
5984 wxPoint *arg2 = 0 ;
5985 wxRect *result = 0 ;
5986 wxPoint temp1 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "topLeft",(char *) "bottomRight", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5995 {
5996 arg1 = &temp1;
5997 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5998 }
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 wxPoint *arg1 = 0 ;
6019 wxSize *arg2 = 0 ;
6020 wxRect *result = 0 ;
6021 wxPoint temp1 ;
6022 wxSize temp2 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "pos",(char *) "size", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6030 {
6031 arg1 = &temp1;
6032 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6033 }
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6045 return resultobj;
6046 fail:
6047 return NULL;
6048 }
6049
6050
6051 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj = 0;
6053 wxSize *arg1 = 0 ;
6054 wxRect *result = 0 ;
6055 wxSize temp1 ;
6056 PyObject * obj0 = 0 ;
6057 char * kwnames[] = {
6058 (char *) "size", NULL
6059 };
6060
6061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6062 {
6063 arg1 = &temp1;
6064 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6065 }
6066 {
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6073 return resultobj;
6074 fail:
6075 return NULL;
6076 }
6077
6078
6079 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6080 PyObject *resultobj = 0;
6081 wxRect *arg1 = (wxRect *) 0 ;
6082 void *argp1 = 0 ;
6083 int res1 = 0 ;
6084 PyObject *swig_obj[1] ;
6085
6086 if (!args) SWIG_fail;
6087 swig_obj[0] = args;
6088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6089 if (!SWIG_IsOK(res1)) {
6090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6091 }
6092 arg1 = reinterpret_cast< wxRect * >(argp1);
6093 {
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 delete arg1;
6096
6097 wxPyEndAllowThreads(__tstate);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 resultobj = SWIG_Py_Void();
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6108 PyObject *resultobj = 0;
6109 wxRect *arg1 = (wxRect *) 0 ;
6110 int result;
6111 void *argp1 = 0 ;
6112 int res1 = 0 ;
6113 PyObject *swig_obj[1] ;
6114
6115 if (!args) SWIG_fail;
6116 swig_obj[0] = args;
6117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6118 if (!SWIG_IsOK(res1)) {
6119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6120 }
6121 arg1 = reinterpret_cast< wxRect * >(argp1);
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (int)((wxRect const *)arg1)->GetX();
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 resultobj = SWIG_From_int(static_cast< int >(result));
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj = 0;
6137 wxRect *arg1 = (wxRect *) 0 ;
6138 int arg2 ;
6139 void *argp1 = 0 ;
6140 int res1 = 0 ;
6141 int val2 ;
6142 int ecode2 = 0 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "self",(char *) "x", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6151 if (!SWIG_IsOK(res1)) {
6152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6153 }
6154 arg1 = reinterpret_cast< wxRect * >(argp1);
6155 ecode2 = SWIG_AsVal_int(obj1, &val2);
6156 if (!SWIG_IsOK(ecode2)) {
6157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6158 }
6159 arg2 = static_cast< int >(val2);
6160 {
6161 PyThreadState* __tstate = wxPyBeginAllowThreads();
6162 (arg1)->SetX(arg2);
6163 wxPyEndAllowThreads(__tstate);
6164 if (PyErr_Occurred()) SWIG_fail;
6165 }
6166 resultobj = SWIG_Py_Void();
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6174 PyObject *resultobj = 0;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 int result;
6177 void *argp1 = 0 ;
6178 int res1 = 0 ;
6179 PyObject *swig_obj[1] ;
6180
6181 if (!args) SWIG_fail;
6182 swig_obj[0] = args;
6183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6184 if (!SWIG_IsOK(res1)) {
6185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6186 }
6187 arg1 = reinterpret_cast< wxRect * >(argp1);
6188 {
6189 PyThreadState* __tstate = wxPyBeginAllowThreads();
6190 result = (int)(arg1)->GetY();
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 resultobj = SWIG_From_int(static_cast< int >(result));
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj = 0;
6203 wxRect *arg1 = (wxRect *) 0 ;
6204 int arg2 ;
6205 void *argp1 = 0 ;
6206 int res1 = 0 ;
6207 int val2 ;
6208 int ecode2 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 char * kwnames[] = {
6212 (char *) "self",(char *) "y", NULL
6213 };
6214
6215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6217 if (!SWIG_IsOK(res1)) {
6218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6219 }
6220 arg1 = reinterpret_cast< wxRect * >(argp1);
6221 ecode2 = SWIG_AsVal_int(obj1, &val2);
6222 if (!SWIG_IsOK(ecode2)) {
6223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6224 }
6225 arg2 = static_cast< int >(val2);
6226 {
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 (arg1)->SetY(arg2);
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 resultobj = SWIG_Py_Void();
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240 PyObject *resultobj = 0;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int result;
6243 void *argp1 = 0 ;
6244 int res1 = 0 ;
6245 PyObject *swig_obj[1] ;
6246
6247 if (!args) SWIG_fail;
6248 swig_obj[0] = args;
6249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6250 if (!SWIG_IsOK(res1)) {
6251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6252 }
6253 arg1 = reinterpret_cast< wxRect * >(argp1);
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (int)((wxRect const *)arg1)->GetWidth();
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_From_int(static_cast< int >(result));
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int arg2 ;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 int val2 ;
6274 int ecode2 = 0 ;
6275 PyObject * obj0 = 0 ;
6276 PyObject * obj1 = 0 ;
6277 char * kwnames[] = {
6278 (char *) "self",(char *) "w", NULL
6279 };
6280
6281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6283 if (!SWIG_IsOK(res1)) {
6284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6285 }
6286 arg1 = reinterpret_cast< wxRect * >(argp1);
6287 ecode2 = SWIG_AsVal_int(obj1, &val2);
6288 if (!SWIG_IsOK(ecode2)) {
6289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6290 }
6291 arg2 = static_cast< int >(val2);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 (arg1)->SetWidth(arg2);
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_Py_Void();
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int result;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 PyObject *swig_obj[1] ;
6312
6313 if (!args) SWIG_fail;
6314 swig_obj[0] = args;
6315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6316 if (!SWIG_IsOK(res1)) {
6317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6318 }
6319 arg1 = reinterpret_cast< wxRect * >(argp1);
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (int)((wxRect const *)arg1)->GetHeight();
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 resultobj = SWIG_From_int(static_cast< int >(result));
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6334 PyObject *resultobj = 0;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int arg2 ;
6337 void *argp1 = 0 ;
6338 int res1 = 0 ;
6339 int val2 ;
6340 int ecode2 = 0 ;
6341 PyObject * obj0 = 0 ;
6342 PyObject * obj1 = 0 ;
6343 char * kwnames[] = {
6344 (char *) "self",(char *) "h", NULL
6345 };
6346
6347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6349 if (!SWIG_IsOK(res1)) {
6350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6351 }
6352 arg1 = reinterpret_cast< wxRect * >(argp1);
6353 ecode2 = SWIG_AsVal_int(obj1, &val2);
6354 if (!SWIG_IsOK(ecode2)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6356 }
6357 arg2 = static_cast< int >(val2);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 (arg1)->SetHeight(arg2);
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_Py_Void();
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 wxPoint result;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 PyObject *swig_obj[1] ;
6378
6379 if (!args) SWIG_fail;
6380 swig_obj[0] = args;
6381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = ((wxRect const *)arg1)->GetPosition();
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 wxPoint *arg2 = 0 ;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 wxPoint temp2 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "self",(char *) "p", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6414 if (!SWIG_IsOK(res1)) {
6415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6416 }
6417 arg1 = reinterpret_cast< wxRect * >(argp1);
6418 {
6419 arg2 = &temp2;
6420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6421 }
6422 {
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 (arg1)->SetPosition((wxPoint const &)*arg2);
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_Py_Void();
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6436 PyObject *resultobj = 0;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 wxSize result;
6439 void *argp1 = 0 ;
6440 int res1 = 0 ;
6441 PyObject *swig_obj[1] ;
6442
6443 if (!args) SWIG_fail;
6444 swig_obj[0] = args;
6445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6446 if (!SWIG_IsOK(res1)) {
6447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6448 }
6449 arg1 = reinterpret_cast< wxRect * >(argp1);
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = ((wxRect const *)arg1)->GetSize();
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj = 0;
6465 wxRect *arg1 = (wxRect *) 0 ;
6466 wxSize *arg2 = 0 ;
6467 void *argp1 = 0 ;
6468 int res1 = 0 ;
6469 wxSize temp2 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char * kwnames[] = {
6473 (char *) "self",(char *) "s", NULL
6474 };
6475
6476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6478 if (!SWIG_IsOK(res1)) {
6479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6480 }
6481 arg1 = reinterpret_cast< wxRect * >(argp1);
6482 {
6483 arg2 = &temp2;
6484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 (arg1)->SetSize((wxSize const &)*arg2);
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_Py_Void();
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6500 PyObject *resultobj = 0;
6501 wxRect *arg1 = (wxRect *) 0 ;
6502 bool result;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 PyObject *swig_obj[1] ;
6506
6507 if (!args) SWIG_fail;
6508 swig_obj[0] = args;
6509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6510 if (!SWIG_IsOK(res1)) {
6511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6512 }
6513 arg1 = reinterpret_cast< wxRect * >(argp1);
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (bool)((wxRect const *)arg1)->IsEmpty();
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 {
6521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6522 }
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6530 PyObject *resultobj = 0;
6531 wxRect *arg1 = (wxRect *) 0 ;
6532 wxPoint result;
6533 void *argp1 = 0 ;
6534 int res1 = 0 ;
6535 PyObject *swig_obj[1] ;
6536
6537 if (!args) SWIG_fail;
6538 swig_obj[0] = args;
6539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6540 if (!SWIG_IsOK(res1)) {
6541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6542 }
6543 arg1 = reinterpret_cast< wxRect * >(argp1);
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = ((wxRect const *)arg1)->GetTopLeft();
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 wxPoint *arg2 = 0 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 wxPoint temp2 ;
6564 PyObject * obj0 = 0 ;
6565 PyObject * obj1 = 0 ;
6566 char * kwnames[] = {
6567 (char *) "self",(char *) "p", NULL
6568 };
6569
6570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6572 if (!SWIG_IsOK(res1)) {
6573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6574 }
6575 arg1 = reinterpret_cast< wxRect * >(argp1);
6576 {
6577 arg2 = &temp2;
6578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6579 }
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_Py_Void();
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 wxPoint result;
6597 void *argp1 = 0 ;
6598 int res1 = 0 ;
6599 PyObject *swig_obj[1] ;
6600
6601 if (!args) SWIG_fail;
6602 swig_obj[0] = args;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = ((wxRect const *)arg1)->GetBottomRight();
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj = 0;
6623 wxRect *arg1 = (wxRect *) 0 ;
6624 wxPoint *arg2 = 0 ;
6625 void *argp1 = 0 ;
6626 int res1 = 0 ;
6627 wxPoint temp2 ;
6628 PyObject * obj0 = 0 ;
6629 PyObject * obj1 = 0 ;
6630 char * kwnames[] = {
6631 (char *) "self",(char *) "p", NULL
6632 };
6633
6634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6636 if (!SWIG_IsOK(res1)) {
6637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6638 }
6639 arg1 = reinterpret_cast< wxRect * >(argp1);
6640 {
6641 arg2 = &temp2;
6642 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 resultobj = SWIG_Py_Void();
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6658 PyObject *resultobj = 0;
6659 wxRect *arg1 = (wxRect *) 0 ;
6660 int result;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 PyObject *swig_obj[1] ;
6664
6665 if (!args) SWIG_fail;
6666 swig_obj[0] = args;
6667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6668 if (!SWIG_IsOK(res1)) {
6669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6670 }
6671 arg1 = reinterpret_cast< wxRect * >(argp1);
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (int)((wxRect const *)arg1)->GetLeft();
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 resultobj = SWIG_From_int(static_cast< int >(result));
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 int result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = (int)((wxRect const *)arg1)->GetTop();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_From_int(static_cast< int >(result));
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 int result;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 PyObject *swig_obj[1] ;
6720
6721 if (!args) SWIG_fail;
6722 swig_obj[0] = args;
6723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 result = (int)((wxRect const *)arg1)->GetBottom();
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_From_int(static_cast< int >(result));
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742 PyObject *resultobj = 0;
6743 wxRect *arg1 = (wxRect *) 0 ;
6744 int result;
6745 void *argp1 = 0 ;
6746 int res1 = 0 ;
6747 PyObject *swig_obj[1] ;
6748
6749 if (!args) SWIG_fail;
6750 swig_obj[0] = args;
6751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6752 if (!SWIG_IsOK(res1)) {
6753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6754 }
6755 arg1 = reinterpret_cast< wxRect * >(argp1);
6756 {
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (int)((wxRect const *)arg1)->GetRight();
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_From_int(static_cast< int >(result));
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 int arg2 ;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 int val2 ;
6776 int ecode2 = 0 ;
6777 PyObject * obj0 = 0 ;
6778 PyObject * obj1 = 0 ;
6779 char * kwnames[] = {
6780 (char *) "self",(char *) "left", NULL
6781 };
6782
6783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6785 if (!SWIG_IsOK(res1)) {
6786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6787 }
6788 arg1 = reinterpret_cast< wxRect * >(argp1);
6789 ecode2 = SWIG_AsVal_int(obj1, &val2);
6790 if (!SWIG_IsOK(ecode2)) {
6791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6792 }
6793 arg2 = static_cast< int >(val2);
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 (arg1)->SetLeft(arg2);
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_Py_Void();
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6808 PyObject *resultobj = 0;
6809 wxRect *arg1 = (wxRect *) 0 ;
6810 int arg2 ;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 int val2 ;
6814 int ecode2 = 0 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char * kwnames[] = {
6818 (char *) "self",(char *) "right", NULL
6819 };
6820
6821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 ecode2 = SWIG_AsVal_int(obj1, &val2);
6828 if (!SWIG_IsOK(ecode2)) {
6829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6830 }
6831 arg2 = static_cast< int >(val2);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 (arg1)->SetRight(arg2);
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_Py_Void();
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj = 0;
6847 wxRect *arg1 = (wxRect *) 0 ;
6848 int arg2 ;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 int val2 ;
6852 int ecode2 = 0 ;
6853 PyObject * obj0 = 0 ;
6854 PyObject * obj1 = 0 ;
6855 char * kwnames[] = {
6856 (char *) "self",(char *) "top", NULL
6857 };
6858
6859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6861 if (!SWIG_IsOK(res1)) {
6862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6863 }
6864 arg1 = reinterpret_cast< wxRect * >(argp1);
6865 ecode2 = SWIG_AsVal_int(obj1, &val2);
6866 if (!SWIG_IsOK(ecode2)) {
6867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6868 }
6869 arg2 = static_cast< int >(val2);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 (arg1)->SetTop(arg2);
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_Py_Void();
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int arg2 ;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 int val2 ;
6890 int ecode2 = 0 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char * kwnames[] = {
6894 (char *) "self",(char *) "bottom", NULL
6895 };
6896
6897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 ecode2 = SWIG_AsVal_int(obj1, &val2);
6904 if (!SWIG_IsOK(ecode2)) {
6905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6906 }
6907 arg2 = static_cast< int >(val2);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 (arg1)->SetBottom(arg2);
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_Py_Void();
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 int arg2 ;
6925 int arg3 ;
6926 wxRect *result = 0 ;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 int val2 ;
6930 int ecode2 = 0 ;
6931 int val3 ;
6932 int ecode3 = 0 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 PyObject * obj2 = 0 ;
6936 char * kwnames[] = {
6937 (char *) "self",(char *) "dx",(char *) "dy", NULL
6938 };
6939
6940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6942 if (!SWIG_IsOK(res1)) {
6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6944 }
6945 arg1 = reinterpret_cast< wxRect * >(argp1);
6946 ecode2 = SWIG_AsVal_int(obj1, &val2);
6947 if (!SWIG_IsOK(ecode2)) {
6948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6949 }
6950 arg2 = static_cast< int >(val2);
6951 ecode3 = SWIG_AsVal_int(obj2, &val3);
6952 if (!SWIG_IsOK(ecode3)) {
6953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6954 }
6955 arg3 = static_cast< int >(val3);
6956 {
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 {
6959 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6960 result = (wxRect *) &_result_ref;
6961 }
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6973 PyObject *resultobj = 0;
6974 wxRect *arg1 = (wxRect *) 0 ;
6975 int arg2 ;
6976 int arg3 ;
6977 wxRect *result = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 int val2 ;
6981 int ecode2 = 0 ;
6982 int val3 ;
6983 int ecode3 = 0 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 PyObject * obj2 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "dx",(char *) "dy", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 ecode3 = SWIG_AsVal_int(obj2, &val3);
7003 if (!SWIG_IsOK(ecode3)) {
7004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7005 }
7006 arg3 = static_cast< int >(val3);
7007 {
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 {
7010 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7011 result = (wxRect *) &_result_ref;
7012 }
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj = 0;
7025 wxRect *arg1 = (wxRect *) 0 ;
7026 int arg2 ;
7027 int arg3 ;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 int val2 ;
7031 int ecode2 = 0 ;
7032 int val3 ;
7033 int ecode3 = 0 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 PyObject * obj2 = 0 ;
7037 char * kwnames[] = {
7038 (char *) "self",(char *) "dx",(char *) "dy", NULL
7039 };
7040
7041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7043 if (!SWIG_IsOK(res1)) {
7044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7045 }
7046 arg1 = reinterpret_cast< wxRect * >(argp1);
7047 ecode2 = SWIG_AsVal_int(obj1, &val2);
7048 if (!SWIG_IsOK(ecode2)) {
7049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7050 }
7051 arg2 = static_cast< int >(val2);
7052 ecode3 = SWIG_AsVal_int(obj2, &val3);
7053 if (!SWIG_IsOK(ecode3)) {
7054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7055 }
7056 arg3 = static_cast< int >(val3);
7057 {
7058 PyThreadState* __tstate = wxPyBeginAllowThreads();
7059 (arg1)->Offset(arg2,arg3);
7060 wxPyEndAllowThreads(__tstate);
7061 if (PyErr_Occurred()) SWIG_fail;
7062 }
7063 resultobj = SWIG_Py_Void();
7064 return resultobj;
7065 fail:
7066 return NULL;
7067 }
7068
7069
7070 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7071 PyObject *resultobj = 0;
7072 wxRect *arg1 = (wxRect *) 0 ;
7073 wxPoint *arg2 = 0 ;
7074 void *argp1 = 0 ;
7075 int res1 = 0 ;
7076 wxPoint temp2 ;
7077 PyObject * obj0 = 0 ;
7078 PyObject * obj1 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "pt", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7087 }
7088 arg1 = reinterpret_cast< wxRect * >(argp1);
7089 {
7090 arg2 = &temp2;
7091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7092 }
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 (arg1)->Offset((wxPoint const &)*arg2);
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_Py_Void();
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj = 0;
7108 wxRect *arg1 = (wxRect *) 0 ;
7109 wxRect *arg2 = 0 ;
7110 wxRect result;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 wxRect temp2 ;
7114 PyObject * obj0 = 0 ;
7115 PyObject * obj1 = 0 ;
7116 char * kwnames[] = {
7117 (char *) "self",(char *) "rect", NULL
7118 };
7119
7120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7122 if (!SWIG_IsOK(res1)) {
7123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7124 }
7125 arg1 = reinterpret_cast< wxRect * >(argp1);
7126 {
7127 arg2 = &temp2;
7128 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7129 }
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (arg1)->Intersect((wxRect const &)*arg2);
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 wxRect *arg2 = 0 ;
7147 wxRect result;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 wxRect temp2 ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char * kwnames[] = {
7154 (char *) "self",(char *) "rect", NULL
7155 };
7156
7157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7159 if (!SWIG_IsOK(res1)) {
7160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7161 }
7162 arg1 = reinterpret_cast< wxRect * >(argp1);
7163 {
7164 arg2 = &temp2;
7165 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7166 }
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 result = (arg1)->Union((wxRect const &)*arg2);
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj = 0;
7182 wxRect *arg1 = (wxRect *) 0 ;
7183 wxRect *arg2 = 0 ;
7184 wxRect result;
7185 void *argp1 = 0 ;
7186 int res1 = 0 ;
7187 wxRect temp2 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "self",(char *) "rect", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7196 if (!SWIG_IsOK(res1)) {
7197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7198 }
7199 arg1 = reinterpret_cast< wxRect * >(argp1);
7200 {
7201 arg2 = &temp2;
7202 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7203 }
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj = 0;
7219 wxRect *arg1 = (wxRect *) 0 ;
7220 wxRect *arg2 = 0 ;
7221 wxRect *result = 0 ;
7222 void *argp1 = 0 ;
7223 int res1 = 0 ;
7224 wxRect temp2 ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 char * kwnames[] = {
7228 (char *) "self",(char *) "rect", NULL
7229 };
7230
7231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7233 if (!SWIG_IsOK(res1)) {
7234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7235 }
7236 arg1 = reinterpret_cast< wxRect * >(argp1);
7237 {
7238 arg2 = &temp2;
7239 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7240 }
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 {
7244 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7245 result = (wxRect *) &_result_ref;
7246 }
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 bool result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 {
7288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7289 }
7290 return resultobj;
7291 fail:
7292 return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7297 PyObject *resultobj = 0;
7298 wxRect *arg1 = (wxRect *) 0 ;
7299 wxRect *arg2 = 0 ;
7300 bool result;
7301 void *argp1 = 0 ;
7302 int res1 = 0 ;
7303 wxRect temp2 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "self",(char *) "rect", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7312 if (!SWIG_IsOK(res1)) {
7313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7314 }
7315 arg1 = reinterpret_cast< wxRect * >(argp1);
7316 {
7317 arg2 = &temp2;
7318 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7319 }
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 int arg2 ;
7339 int arg3 ;
7340 bool result;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 int val2 ;
7344 int ecode2 = 0 ;
7345 int val3 ;
7346 int ecode3 = 0 ;
7347 PyObject * obj0 = 0 ;
7348 PyObject * obj1 = 0 ;
7349 PyObject * obj2 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "x",(char *) "y", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7358 }
7359 arg1 = reinterpret_cast< wxRect * >(argp1);
7360 ecode2 = SWIG_AsVal_int(obj1, &val2);
7361 if (!SWIG_IsOK(ecode2)) {
7362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7363 }
7364 arg2 = static_cast< int >(val2);
7365 ecode3 = SWIG_AsVal_int(obj2, &val3);
7366 if (!SWIG_IsOK(ecode3)) {
7367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7368 }
7369 arg3 = static_cast< int >(val3);
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7373 wxPyEndAllowThreads(__tstate);
7374 if (PyErr_Occurred()) SWIG_fail;
7375 }
7376 {
7377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7378 }
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj = 0;
7387 wxRect *arg1 = (wxRect *) 0 ;
7388 wxPoint *arg2 = 0 ;
7389 bool result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 wxPoint temp2 ;
7393 PyObject * obj0 = 0 ;
7394 PyObject * obj1 = 0 ;
7395 char * kwnames[] = {
7396 (char *) "self",(char *) "pt", NULL
7397 };
7398
7399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7401 if (!SWIG_IsOK(res1)) {
7402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7403 }
7404 arg1 = reinterpret_cast< wxRect * >(argp1);
7405 {
7406 arg2 = &temp2;
7407 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7408 }
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 {
7416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7417 }
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj = 0;
7426 wxRect *arg1 = (wxRect *) 0 ;
7427 wxRect *arg2 = 0 ;
7428 bool result;
7429 void *argp1 = 0 ;
7430 int res1 = 0 ;
7431 wxRect temp2 ;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char * kwnames[] = {
7435 (char *) "self",(char *) "rect", NULL
7436 };
7437
7438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7440 if (!SWIG_IsOK(res1)) {
7441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7442 }
7443 arg1 = reinterpret_cast< wxRect * >(argp1);
7444 {
7445 arg2 = &temp2;
7446 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxRect *arg2 = 0 ;
7467 int arg3 = (int) wxBOTH ;
7468 wxRect result;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxRect temp2 ;
7472 int val3 ;
7473 int ecode3 = 0 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 PyObject * obj2 = 0 ;
7477 char * kwnames[] = {
7478 (char *) "self",(char *) "r",(char *) "dir", NULL
7479 };
7480
7481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7485 }
7486 arg1 = reinterpret_cast< wxRect * >(argp1);
7487 {
7488 arg2 = &temp2;
7489 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7490 }
7491 if (obj2) {
7492 ecode3 = SWIG_AsVal_int(obj2, &val3);
7493 if (!SWIG_IsOK(ecode3)) {
7494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7495 }
7496 arg3 = static_cast< int >(val3);
7497 }
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7512 PyObject *resultobj = 0;
7513 wxRect *arg1 = (wxRect *) 0 ;
7514 int arg2 ;
7515 void *argp1 = 0 ;
7516 int res1 = 0 ;
7517 int val2 ;
7518 int ecode2 = 0 ;
7519 PyObject *swig_obj[2] ;
7520
7521 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7525 }
7526 arg1 = reinterpret_cast< wxRect * >(argp1);
7527 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7528 if (!SWIG_IsOK(ecode2)) {
7529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7530 }
7531 arg2 = static_cast< int >(val2);
7532 if (arg1) (arg1)->x = arg2;
7533
7534 resultobj = SWIG_Py_Void();
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7542 PyObject *resultobj = 0;
7543 wxRect *arg1 = (wxRect *) 0 ;
7544 int result;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 PyObject *swig_obj[1] ;
7548
7549 if (!args) SWIG_fail;
7550 swig_obj[0] = args;
7551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7552 if (!SWIG_IsOK(res1)) {
7553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7554 }
7555 arg1 = reinterpret_cast< wxRect * >(argp1);
7556 result = (int) ((arg1)->x);
7557 resultobj = SWIG_From_int(static_cast< int >(result));
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7565 PyObject *resultobj = 0;
7566 wxRect *arg1 = (wxRect *) 0 ;
7567 int arg2 ;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 int val2 ;
7571 int ecode2 = 0 ;
7572 PyObject *swig_obj[2] ;
7573
7574 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7576 if (!SWIG_IsOK(res1)) {
7577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7578 }
7579 arg1 = reinterpret_cast< wxRect * >(argp1);
7580 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7581 if (!SWIG_IsOK(ecode2)) {
7582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7583 }
7584 arg2 = static_cast< int >(val2);
7585 if (arg1) (arg1)->y = arg2;
7586
7587 resultobj = SWIG_Py_Void();
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7595 PyObject *resultobj = 0;
7596 wxRect *arg1 = (wxRect *) 0 ;
7597 int result;
7598 void *argp1 = 0 ;
7599 int res1 = 0 ;
7600 PyObject *swig_obj[1] ;
7601
7602 if (!args) SWIG_fail;
7603 swig_obj[0] = args;
7604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 result = (int) ((arg1)->y);
7610 resultobj = SWIG_From_int(static_cast< int >(result));
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7618 PyObject *resultobj = 0;
7619 wxRect *arg1 = (wxRect *) 0 ;
7620 int arg2 ;
7621 void *argp1 = 0 ;
7622 int res1 = 0 ;
7623 int val2 ;
7624 int ecode2 = 0 ;
7625 PyObject *swig_obj[2] ;
7626
7627 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7629 if (!SWIG_IsOK(res1)) {
7630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7631 }
7632 arg1 = reinterpret_cast< wxRect * >(argp1);
7633 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7634 if (!SWIG_IsOK(ecode2)) {
7635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7636 }
7637 arg2 = static_cast< int >(val2);
7638 if (arg1) (arg1)->width = arg2;
7639
7640 resultobj = SWIG_Py_Void();
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxRect *arg1 = (wxRect *) 0 ;
7650 int result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 PyObject *swig_obj[1] ;
7654
7655 if (!args) SWIG_fail;
7656 swig_obj[0] = args;
7657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7660 }
7661 arg1 = reinterpret_cast< wxRect * >(argp1);
7662 result = (int) ((arg1)->width);
7663 resultobj = SWIG_From_int(static_cast< int >(result));
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 int arg2 ;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 int val2 ;
7677 int ecode2 = 0 ;
7678 PyObject *swig_obj[2] ;
7679
7680 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7684 }
7685 arg1 = reinterpret_cast< wxRect * >(argp1);
7686 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7689 }
7690 arg2 = static_cast< int >(val2);
7691 if (arg1) (arg1)->height = arg2;
7692
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7701 PyObject *resultobj = 0;
7702 wxRect *arg1 = (wxRect *) 0 ;
7703 int result;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 PyObject *swig_obj[1] ;
7707
7708 if (!args) SWIG_fail;
7709 swig_obj[0] = args;
7710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 result = (int) ((arg1)->height);
7716 resultobj = SWIG_From_int(static_cast< int >(result));
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int arg2 = (int) 0 ;
7727 int arg3 = (int) 0 ;
7728 int arg4 = (int) 0 ;
7729 int arg5 = (int) 0 ;
7730 void *argp1 = 0 ;
7731 int res1 = 0 ;
7732 int val2 ;
7733 int ecode2 = 0 ;
7734 int val3 ;
7735 int ecode3 = 0 ;
7736 int val4 ;
7737 int ecode4 = 0 ;
7738 int val5 ;
7739 int ecode5 = 0 ;
7740 PyObject * obj0 = 0 ;
7741 PyObject * obj1 = 0 ;
7742 PyObject * obj2 = 0 ;
7743 PyObject * obj3 = 0 ;
7744 PyObject * obj4 = 0 ;
7745 char * kwnames[] = {
7746 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7747 };
7748
7749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7751 if (!SWIG_IsOK(res1)) {
7752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7753 }
7754 arg1 = reinterpret_cast< wxRect * >(argp1);
7755 if (obj1) {
7756 ecode2 = SWIG_AsVal_int(obj1, &val2);
7757 if (!SWIG_IsOK(ecode2)) {
7758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7759 }
7760 arg2 = static_cast< int >(val2);
7761 }
7762 if (obj2) {
7763 ecode3 = SWIG_AsVal_int(obj2, &val3);
7764 if (!SWIG_IsOK(ecode3)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7766 }
7767 arg3 = static_cast< int >(val3);
7768 }
7769 if (obj3) {
7770 ecode4 = SWIG_AsVal_int(obj3, &val4);
7771 if (!SWIG_IsOK(ecode4)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7773 }
7774 arg4 = static_cast< int >(val4);
7775 }
7776 if (obj4) {
7777 ecode5 = SWIG_AsVal_int(obj4, &val5);
7778 if (!SWIG_IsOK(ecode5)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7780 }
7781 arg5 = static_cast< int >(val5);
7782 }
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_Py_Void();
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 PyObject *resultobj = 0;
7798 wxRect *arg1 = (wxRect *) 0 ;
7799 PyObject *result = 0 ;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 PyObject *swig_obj[1] ;
7803
7804 if (!args) SWIG_fail;
7805 swig_obj[0] = args;
7806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7809 }
7810 arg1 = reinterpret_cast< wxRect * >(argp1);
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 result = (PyObject *)wxRect_Get(arg1);
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 resultobj = result;
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *obj;
7826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7827 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7828 return SWIG_Py_Void();
7829 }
7830
7831 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7832 return SWIG_Python_InitShadowInstance(args);
7833 }
7834
7835 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj = 0;
7837 wxRect *arg1 = (wxRect *) 0 ;
7838 wxRect *arg2 = (wxRect *) 0 ;
7839 PyObject *result = 0 ;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 void *argp2 = 0 ;
7843 int res2 = 0 ;
7844 PyObject * obj0 = 0 ;
7845 PyObject * obj1 = 0 ;
7846 char * kwnames[] = {
7847 (char *) "r1",(char *) "r2", NULL
7848 };
7849
7850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7852 if (!SWIG_IsOK(res1)) {
7853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7854 }
7855 arg1 = reinterpret_cast< wxRect * >(argp1);
7856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7857 if (!SWIG_IsOK(res2)) {
7858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7859 }
7860 arg2 = reinterpret_cast< wxRect * >(argp2);
7861 {
7862 if (!wxPyCheckForApp()) SWIG_fail;
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (PyObject *)wxIntersectRect(arg1,arg2);
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 resultobj = result;
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7876 PyObject *resultobj = 0;
7877 double arg1 = (double) 0.0 ;
7878 double arg2 = (double) 0.0 ;
7879 wxPoint2D *result = 0 ;
7880 double val1 ;
7881 int ecode1 = 0 ;
7882 double val2 ;
7883 int ecode2 = 0 ;
7884 PyObject * obj0 = 0 ;
7885 PyObject * obj1 = 0 ;
7886 char * kwnames[] = {
7887 (char *) "x",(char *) "y", NULL
7888 };
7889
7890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7891 if (obj0) {
7892 ecode1 = SWIG_AsVal_double(obj0, &val1);
7893 if (!SWIG_IsOK(ecode1)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7895 }
7896 arg1 = static_cast< double >(val1);
7897 }
7898 if (obj1) {
7899 ecode2 = SWIG_AsVal_double(obj1, &val2);
7900 if (!SWIG_IsOK(ecode2)) {
7901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7902 }
7903 arg2 = static_cast< double >(val2);
7904 }
7905 {
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7919 PyObject *resultobj = 0;
7920 wxPoint2D *arg1 = 0 ;
7921 wxPoint2D *result = 0 ;
7922 wxPoint2D temp1 ;
7923 PyObject * obj0 = 0 ;
7924 char * kwnames[] = {
7925 (char *) "pt", NULL
7926 };
7927
7928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7929 {
7930 arg1 = &temp1;
7931 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7932 }
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7947 PyObject *resultobj = 0;
7948 wxPoint *arg1 = 0 ;
7949 wxPoint2D *result = 0 ;
7950 wxPoint temp1 ;
7951 PyObject * obj0 = 0 ;
7952 char * kwnames[] = {
7953 (char *) "pt", NULL
7954 };
7955
7956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7957 {
7958 arg1 = &temp1;
7959 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7960 }
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 PyObject *resultobj = 0;
7976 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7977 int *arg2 = (int *) 0 ;
7978 int *arg3 = (int *) 0 ;
7979 void *argp1 = 0 ;
7980 int res1 = 0 ;
7981 int temp2 ;
7982 int res2 = SWIG_TMPOBJ ;
7983 int temp3 ;
7984 int res3 = SWIG_TMPOBJ ;
7985 PyObject *swig_obj[1] ;
7986
7987 arg2 = &temp2;
7988 arg3 = &temp3;
7989 if (!args) SWIG_fail;
7990 swig_obj[0] = args;
7991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7994 }
7995 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_Py_Void();
8003 if (SWIG_IsTmpObj(res2)) {
8004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8005 } else {
8006 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8008 }
8009 if (SWIG_IsTmpObj(res3)) {
8010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8011 } else {
8012 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8014 }
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8024 int *arg2 = (int *) 0 ;
8025 int *arg3 = (int *) 0 ;
8026 void *argp1 = 0 ;
8027 int res1 = 0 ;
8028 int temp2 ;
8029 int res2 = SWIG_TMPOBJ ;
8030 int temp3 ;
8031 int res3 = SWIG_TMPOBJ ;
8032 PyObject *swig_obj[1] ;
8033
8034 arg2 = &temp2;
8035 arg3 = &temp3;
8036 if (!args) SWIG_fail;
8037 swig_obj[0] = args;
8038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8039 if (!SWIG_IsOK(res1)) {
8040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8041 }
8042 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_Py_Void();
8050 if (SWIG_IsTmpObj(res2)) {
8051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8052 } else {
8053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8055 }
8056 if (SWIG_IsTmpObj(res3)) {
8057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8058 } else {
8059 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8061 }
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 PyObject *resultobj = 0;
8070 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8071 double result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8081 }
8082 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 resultobj = SWIG_From_double(static_cast< double >(result));
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8097 PyObject *resultobj = 0;
8098 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8099 double result;
8100 void *argp1 = 0 ;
8101 int res1 = 0 ;
8102 PyObject *swig_obj[1] ;
8103
8104 if (!args) SWIG_fail;
8105 swig_obj[0] = args;
8106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8107 if (!SWIG_IsOK(res1)) {
8108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8109 }
8110 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8111 {
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 resultobj = SWIG_From_double(static_cast< double >(result));
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj = 0;
8126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8127 double arg2 ;
8128 void *argp1 = 0 ;
8129 int res1 = 0 ;
8130 double val2 ;
8131 int ecode2 = 0 ;
8132 PyObject * obj0 = 0 ;
8133 PyObject * obj1 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "self",(char *) "length", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8140 if (!SWIG_IsOK(res1)) {
8141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8142 }
8143 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8144 ecode2 = SWIG_AsVal_double(obj1, &val2);
8145 if (!SWIG_IsOK(ecode2)) {
8146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8147 }
8148 arg2 = static_cast< double >(val2);
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 (arg1)->SetVectorLength(arg2);
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 resultobj = SWIG_Py_Void();
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8163 PyObject *resultobj = 0;
8164 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8165 double arg2 ;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 double val2 ;
8169 int ecode2 = 0 ;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 char * kwnames[] = {
8173 (char *) "self",(char *) "degrees", NULL
8174 };
8175
8176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8180 }
8181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8182 ecode2 = SWIG_AsVal_double(obj1, &val2);
8183 if (!SWIG_IsOK(ecode2)) {
8184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8185 }
8186 arg2 = static_cast< double >(val2);
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 (arg1)->SetVectorAngle(arg2);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_Py_Void();
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8203 wxPoint2D *arg2 = 0 ;
8204 double result;
8205 void *argp1 = 0 ;
8206 int res1 = 0 ;
8207 wxPoint2D temp2 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char * kwnames[] = {
8211 (char *) "self",(char *) "pt", NULL
8212 };
8213
8214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8218 }
8219 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8220 {
8221 arg2 = &temp2;
8222 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8223 }
8224 {
8225 PyThreadState* __tstate = wxPyBeginAllowThreads();
8226 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8227 wxPyEndAllowThreads(__tstate);
8228 if (PyErr_Occurred()) SWIG_fail;
8229 }
8230 resultobj = SWIG_From_double(static_cast< double >(result));
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = 0;
8239 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8240 wxPoint2D *arg2 = 0 ;
8241 double result;
8242 void *argp1 = 0 ;
8243 int res1 = 0 ;
8244 wxPoint2D temp2 ;
8245 PyObject * obj0 = 0 ;
8246 PyObject * obj1 = 0 ;
8247 char * kwnames[] = {
8248 (char *) "self",(char *) "pt", NULL
8249 };
8250
8251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8253 if (!SWIG_IsOK(res1)) {
8254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8255 }
8256 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8257 {
8258 arg2 = &temp2;
8259 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8260 }
8261 {
8262 PyThreadState* __tstate = wxPyBeginAllowThreads();
8263 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_From_double(static_cast< double >(result));
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8277 wxPoint2D *arg2 = 0 ;
8278 double result;
8279 void *argp1 = 0 ;
8280 int res1 = 0 ;
8281 wxPoint2D temp2 ;
8282 PyObject * obj0 = 0 ;
8283 PyObject * obj1 = 0 ;
8284 char * kwnames[] = {
8285 (char *) "self",(char *) "vec", NULL
8286 };
8287
8288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8290 if (!SWIG_IsOK(res1)) {
8291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8292 }
8293 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8294 {
8295 arg2 = &temp2;
8296 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8297 }
8298 {
8299 PyThreadState* __tstate = wxPyBeginAllowThreads();
8300 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 resultobj = SWIG_From_double(static_cast< double >(result));
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj = 0;
8313 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8314 wxPoint2D *arg2 = 0 ;
8315 double result;
8316 void *argp1 = 0 ;
8317 int res1 = 0 ;
8318 wxPoint2D temp2 ;
8319 PyObject * obj0 = 0 ;
8320 PyObject * obj1 = 0 ;
8321 char * kwnames[] = {
8322 (char *) "self",(char *) "vec", NULL
8323 };
8324
8325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8327 if (!SWIG_IsOK(res1)) {
8328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8329 }
8330 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8331 {
8332 arg2 = &temp2;
8333 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 resultobj = SWIG_From_double(static_cast< double >(result));
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8349 PyObject *resultobj = 0;
8350 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8351 wxPoint2D result;
8352 void *argp1 = 0 ;
8353 int res1 = 0 ;
8354 PyObject *swig_obj[1] ;
8355
8356 if (!args) SWIG_fail;
8357 swig_obj[0] = args;
8358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8361 }
8362 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (arg1)->operator -();
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 wxPoint2D *result = 0 ;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "pt", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 {
8403 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8404 result = (wxPoint2D *) &_result_ref;
8405 }
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8417 PyObject *resultobj = 0;
8418 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8419 wxPoint2D *arg2 = 0 ;
8420 wxPoint2D *result = 0 ;
8421 void *argp1 = 0 ;
8422 int res1 = 0 ;
8423 wxPoint2D temp2 ;
8424 PyObject * obj0 = 0 ;
8425 PyObject * obj1 = 0 ;
8426 char * kwnames[] = {
8427 (char *) "self",(char *) "pt", NULL
8428 };
8429
8430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8432 if (!SWIG_IsOK(res1)) {
8433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8434 }
8435 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8436 {
8437 arg2 = &temp2;
8438 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8439 }
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 {
8443 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8444 result = (wxPoint2D *) &_result_ref;
8445 }
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 wxPoint2D *result = 0 ;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "pt", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 {
8483 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8484 result = (wxPoint2D *) &_result_ref;
8485 }
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8497 PyObject *resultobj = 0;
8498 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8499 wxPoint2D *arg2 = 0 ;
8500 wxPoint2D *result = 0 ;
8501 void *argp1 = 0 ;
8502 int res1 = 0 ;
8503 wxPoint2D temp2 ;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char * kwnames[] = {
8507 (char *) "self",(char *) "pt", NULL
8508 };
8509
8510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8512 if (!SWIG_IsOK(res1)) {
8513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8514 }
8515 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8516 {
8517 arg2 = &temp2;
8518 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 {
8523 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8524 result = (wxPoint2D *) &_result_ref;
8525 }
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 wxPoint2D *arg2 = 0 ;
8540 bool result;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 wxPoint2D temp2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "pt", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8554 }
8555 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8556 {
8557 arg2 = &temp2;
8558 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8559 }
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 {
8567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8568 }
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 bool result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 {
8606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8607 }
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 double arg2 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 double val2 ;
8621 int ecode2 = 0 ;
8622 PyObject *swig_obj[2] ;
8623
8624 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8626 if (!SWIG_IsOK(res1)) {
8627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8628 }
8629 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8630 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8631 if (!SWIG_IsOK(ecode2)) {
8632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8633 }
8634 arg2 = static_cast< double >(val2);
8635 if (arg1) (arg1)->m_x = arg2;
8636
8637 resultobj = SWIG_Py_Void();
8638 return resultobj;
8639 fail:
8640 return NULL;
8641 }
8642
8643
8644 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8645 PyObject *resultobj = 0;
8646 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8647 double result;
8648 void *argp1 = 0 ;
8649 int res1 = 0 ;
8650 PyObject *swig_obj[1] ;
8651
8652 if (!args) SWIG_fail;
8653 swig_obj[0] = args;
8654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8657 }
8658 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8659 result = (double) ((arg1)->m_x);
8660 resultobj = SWIG_From_double(static_cast< double >(result));
8661 return resultobj;
8662 fail:
8663 return NULL;
8664 }
8665
8666
8667 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8668 PyObject *resultobj = 0;
8669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8670 double arg2 ;
8671 void *argp1 = 0 ;
8672 int res1 = 0 ;
8673 double val2 ;
8674 int ecode2 = 0 ;
8675 PyObject *swig_obj[2] ;
8676
8677 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8679 if (!SWIG_IsOK(res1)) {
8680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8681 }
8682 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8683 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8684 if (!SWIG_IsOK(ecode2)) {
8685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8686 }
8687 arg2 = static_cast< double >(val2);
8688 if (arg1) (arg1)->m_y = arg2;
8689
8690 resultobj = SWIG_Py_Void();
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8698 PyObject *resultobj = 0;
8699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8700 double result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 PyObject *swig_obj[1] ;
8704
8705 if (!args) SWIG_fail;
8706 swig_obj[0] = args;
8707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8710 }
8711 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8712 result = (double) ((arg1)->m_y);
8713 resultobj = SWIG_From_double(static_cast< double >(result));
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 double arg2 = (double) 0 ;
8724 double arg3 = (double) 0 ;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 double val2 ;
8728 int ecode2 = 0 ;
8729 double val3 ;
8730 int ecode3 = 0 ;
8731 PyObject * obj0 = 0 ;
8732 PyObject * obj1 = 0 ;
8733 PyObject * obj2 = 0 ;
8734 char * kwnames[] = {
8735 (char *) "self",(char *) "x",(char *) "y", NULL
8736 };
8737
8738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8742 }
8743 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8744 if (obj1) {
8745 ecode2 = SWIG_AsVal_double(obj1, &val2);
8746 if (!SWIG_IsOK(ecode2)) {
8747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8748 }
8749 arg2 = static_cast< double >(val2);
8750 }
8751 if (obj2) {
8752 ecode3 = SWIG_AsVal_double(obj2, &val3);
8753 if (!SWIG_IsOK(ecode3)) {
8754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8755 }
8756 arg3 = static_cast< double >(val3);
8757 }
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 wxPoint2D_Set(arg1,arg2,arg3);
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 resultobj = SWIG_Py_Void();
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 PyObject *result = 0 ;
8775 void *argp1 = 0 ;
8776 int res1 = 0 ;
8777 PyObject *swig_obj[1] ;
8778
8779 if (!args) SWIG_fail;
8780 swig_obj[0] = args;
8781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 {
8787 PyThreadState* __tstate = wxPyBeginAllowThreads();
8788 result = (PyObject *)wxPoint2D_Get(arg1);
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 resultobj = result;
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *obj;
8801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8802 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8803 return SWIG_Py_Void();
8804 }
8805
8806 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8807 return SWIG_Python_InitShadowInstance(args);
8808 }
8809
8810 SWIGINTERN int DefaultPosition_set(PyObject *) {
8811 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8812 return 1;
8813 }
8814
8815
8816 SWIGINTERN PyObject *DefaultPosition_get(void) {
8817 PyObject *pyobj = 0;
8818
8819 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8820 return pyobj;
8821 }
8822
8823
8824 SWIGINTERN int DefaultSize_set(PyObject *) {
8825 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8826 return 1;
8827 }
8828
8829
8830 SWIGINTERN PyObject *DefaultSize_get(void) {
8831 PyObject *pyobj = 0;
8832
8833 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8834 return pyobj;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 PyObject *arg1 = (PyObject *) 0 ;
8841 wxPyInputStream *result = 0 ;
8842 PyObject * obj0 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "p", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8848 arg1 = obj0;
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8863 PyObject *resultobj = 0;
8864 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8865 void *argp1 = 0 ;
8866 int res1 = 0 ;
8867 PyObject *swig_obj[1] ;
8868
8869 if (!args) SWIG_fail;
8870 swig_obj[0] = args;
8871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8872 if (!SWIG_IsOK(res1)) {
8873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8874 }
8875 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8876 {
8877 PyThreadState* __tstate = wxPyBeginAllowThreads();
8878 delete arg1;
8879
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_Py_Void();
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8891 PyObject *resultobj = 0;
8892 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8893 void *argp1 = 0 ;
8894 int res1 = 0 ;
8895 PyObject *swig_obj[1] ;
8896
8897 if (!args) SWIG_fail;
8898 swig_obj[0] = args;
8899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8900 if (!SWIG_IsOK(res1)) {
8901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8902 }
8903 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 (arg1)->close();
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 resultobj = SWIG_Py_Void();
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8918 PyObject *resultobj = 0;
8919 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 PyObject *swig_obj[1] ;
8923
8924 if (!args) SWIG_fail;
8925 swig_obj[0] = args;
8926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8927 if (!SWIG_IsOK(res1)) {
8928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8929 }
8930 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 (arg1)->flush();
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_Py_Void();
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 PyObject *resultobj = 0;
8946 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8947 bool result;
8948 void *argp1 = 0 ;
8949 int res1 = 0 ;
8950 PyObject *swig_obj[1] ;
8951
8952 if (!args) SWIG_fail;
8953 swig_obj[0] = args;
8954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8955 if (!SWIG_IsOK(res1)) {
8956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8957 }
8958 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8959 {
8960 PyThreadState* __tstate = wxPyBeginAllowThreads();
8961 result = (bool)(arg1)->eof();
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 {
8966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj = 0;
8976 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8977 int arg2 = (int) -1 ;
8978 PyObject *result = 0 ;
8979 void *argp1 = 0 ;
8980 int res1 = 0 ;
8981 int val2 ;
8982 int ecode2 = 0 ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 char * kwnames[] = {
8986 (char *) "self",(char *) "size", NULL
8987 };
8988
8989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8991 if (!SWIG_IsOK(res1)) {
8992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8993 }
8994 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8995 if (obj1) {
8996 ecode2 = SWIG_AsVal_int(obj1, &val2);
8997 if (!SWIG_IsOK(ecode2)) {
8998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
8999 }
9000 arg2 = static_cast< int >(val2);
9001 }
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 result = (PyObject *)(arg1)->read(arg2);
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 resultobj = result;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj = 0;
9017 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9018 int arg2 = (int) -1 ;
9019 PyObject *result = 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 int val2 ;
9023 int ecode2 = 0 ;
9024 PyObject * obj0 = 0 ;
9025 PyObject * obj1 = 0 ;
9026 char * kwnames[] = {
9027 (char *) "self",(char *) "size", NULL
9028 };
9029
9030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9032 if (!SWIG_IsOK(res1)) {
9033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9034 }
9035 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9036 if (obj1) {
9037 ecode2 = SWIG_AsVal_int(obj1, &val2);
9038 if (!SWIG_IsOK(ecode2)) {
9039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9040 }
9041 arg2 = static_cast< int >(val2);
9042 }
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 result = (PyObject *)(arg1)->readline(arg2);
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 resultobj = result;
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9057 PyObject *resultobj = 0;
9058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9059 int arg2 = (int) -1 ;
9060 PyObject *result = 0 ;
9061 void *argp1 = 0 ;
9062 int res1 = 0 ;
9063 int val2 ;
9064 int ecode2 = 0 ;
9065 PyObject * obj0 = 0 ;
9066 PyObject * obj1 = 0 ;
9067 char * kwnames[] = {
9068 (char *) "self",(char *) "sizehint", NULL
9069 };
9070
9071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9073 if (!SWIG_IsOK(res1)) {
9074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9075 }
9076 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9077 if (obj1) {
9078 ecode2 = SWIG_AsVal_int(obj1, &val2);
9079 if (!SWIG_IsOK(ecode2)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9081 }
9082 arg2 = static_cast< int >(val2);
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 result = (PyObject *)(arg1)->readlines(arg2);
9087 wxPyEndAllowThreads(__tstate);
9088 if (PyErr_Occurred()) SWIG_fail;
9089 }
9090 resultobj = result;
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj = 0;
9099 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9100 int arg2 ;
9101 int arg3 = (int) 0 ;
9102 void *argp1 = 0 ;
9103 int res1 = 0 ;
9104 int val2 ;
9105 int ecode2 = 0 ;
9106 int val3 ;
9107 int ecode3 = 0 ;
9108 PyObject * obj0 = 0 ;
9109 PyObject * obj1 = 0 ;
9110 PyObject * obj2 = 0 ;
9111 char * kwnames[] = {
9112 (char *) "self",(char *) "offset",(char *) "whence", NULL
9113 };
9114
9115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9121 ecode2 = SWIG_AsVal_int(obj1, &val2);
9122 if (!SWIG_IsOK(ecode2)) {
9123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9124 }
9125 arg2 = static_cast< int >(val2);
9126 if (obj2) {
9127 ecode3 = SWIG_AsVal_int(obj2, &val3);
9128 if (!SWIG_IsOK(ecode3)) {
9129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9130 }
9131 arg3 = static_cast< int >(val3);
9132 }
9133 {
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 (arg1)->seek(arg2,arg3);
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 resultobj = SWIG_Py_Void();
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9149 int result;
9150 void *argp1 = 0 ;
9151 int res1 = 0 ;
9152 PyObject *swig_obj[1] ;
9153
9154 if (!args) SWIG_fail;
9155 swig_obj[0] = args;
9156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9157 if (!SWIG_IsOK(res1)) {
9158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9159 }
9160 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 result = (int)(arg1)->tell();
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_From_int(static_cast< int >(result));
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 PyObject *resultobj = 0;
9176 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9177 char result;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 PyObject *swig_obj[1] ;
9181
9182 if (!args) SWIG_fail;
9183 swig_obj[0] = args;
9184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (char)(arg1)->Peek();
9192 wxPyEndAllowThreads(__tstate);
9193 if (PyErr_Occurred()) SWIG_fail;
9194 }
9195 resultobj = SWIG_From_char(static_cast< char >(result));
9196 return resultobj;
9197 fail:
9198 return NULL;
9199 }
9200
9201
9202 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9203 PyObject *resultobj = 0;
9204 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9205 char result;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 PyObject *swig_obj[1] ;
9209
9210 if (!args) SWIG_fail;
9211 swig_obj[0] = args;
9212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9213 if (!SWIG_IsOK(res1)) {
9214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9215 }
9216 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (char)(arg1)->GetC();
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 resultobj = SWIG_From_char(static_cast< char >(result));
9224 return resultobj;
9225 fail:
9226 return NULL;
9227 }
9228
9229
9230 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9231 PyObject *resultobj = 0;
9232 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9233 size_t result;
9234 void *argp1 = 0 ;
9235 int res1 = 0 ;
9236 PyObject *swig_obj[1] ;
9237
9238 if (!args) SWIG_fail;
9239 swig_obj[0] = args;
9240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9241 if (!SWIG_IsOK(res1)) {
9242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9243 }
9244 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (size_t)(arg1)->LastRead();
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9261 bool result;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 PyObject *swig_obj[1] ;
9265
9266 if (!args) SWIG_fail;
9267 swig_obj[0] = args;
9268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9271 }
9272 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (bool)(arg1)->CanRead();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 {
9280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9281 }
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9289 PyObject *resultobj = 0;
9290 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9291 bool result;
9292 void *argp1 = 0 ;
9293 int res1 = 0 ;
9294 PyObject *swig_obj[1] ;
9295
9296 if (!args) SWIG_fail;
9297 swig_obj[0] = args;
9298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9299 if (!SWIG_IsOK(res1)) {
9300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9301 }
9302 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 result = (bool)(arg1)->Eof();
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 {
9310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9311 }
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9319 PyObject *resultobj = 0;
9320 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9321 char arg2 ;
9322 bool result;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 char val2 ;
9326 int ecode2 = 0 ;
9327 PyObject * obj0 = 0 ;
9328 PyObject * obj1 = 0 ;
9329 char * kwnames[] = {
9330 (char *) "self",(char *) "c", NULL
9331 };
9332
9333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9337 }
9338 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9339 ecode2 = SWIG_AsVal_char(obj1, &val2);
9340 if (!SWIG_IsOK(ecode2)) {
9341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9342 }
9343 arg2 = static_cast< char >(val2);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (bool)(arg1)->Ungetch(arg2);
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 {
9351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9352 }
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 long arg2 ;
9363 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9364 long result;
9365 void *argp1 = 0 ;
9366 int res1 = 0 ;
9367 long val2 ;
9368 int ecode2 = 0 ;
9369 int val3 ;
9370 int ecode3 = 0 ;
9371 PyObject * obj0 = 0 ;
9372 PyObject * obj1 = 0 ;
9373 PyObject * obj2 = 0 ;
9374 char * kwnames[] = {
9375 (char *) "self",(char *) "pos",(char *) "mode", NULL
9376 };
9377
9378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9382 }
9383 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9384 ecode2 = SWIG_AsVal_long(obj1, &val2);
9385 if (!SWIG_IsOK(ecode2)) {
9386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9387 }
9388 arg2 = static_cast< long >(val2);
9389 if (obj2) {
9390 ecode3 = SWIG_AsVal_int(obj2, &val3);
9391 if (!SWIG_IsOK(ecode3)) {
9392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9393 }
9394 arg3 = static_cast< wxSeekMode >(val3);
9395 }
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 result = (long)(arg1)->SeekI(arg2,arg3);
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 resultobj = SWIG_From_long(static_cast< long >(result));
9403 return resultobj;
9404 fail:
9405 return NULL;
9406 }
9407
9408
9409 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9410 PyObject *resultobj = 0;
9411 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9412 long result;
9413 void *argp1 = 0 ;
9414 int res1 = 0 ;
9415 PyObject *swig_obj[1] ;
9416
9417 if (!args) SWIG_fail;
9418 swig_obj[0] = args;
9419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9420 if (!SWIG_IsOK(res1)) {
9421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9422 }
9423 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (long)(arg1)->TellI();
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = SWIG_From_long(static_cast< long >(result));
9431 return resultobj;
9432 fail:
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9438 PyObject *obj;
9439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9441 return SWIG_Py_Void();
9442 }
9443
9444 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 return SWIG_Python_InitShadowInstance(args);
9446 }
9447
9448 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj = 0;
9450 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9451 PyObject *arg2 = (PyObject *) 0 ;
9452 void *argp1 = 0 ;
9453 int res1 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "obj", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9464 }
9465 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9466 arg2 = obj1;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 wxOutputStream_write(arg1,arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9483 size_t result;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 PyObject *swig_obj[1] ;
9487
9488 if (!args) SWIG_fail;
9489 swig_obj[0] = args;
9490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9493 }
9494 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509 PyObject *obj;
9510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9511 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9512 return SWIG_Py_Void();
9513 }
9514
9515 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj = 0;
9517 wxInputStream *arg1 = (wxInputStream *) 0 ;
9518 wxString *arg2 = 0 ;
9519 wxString *arg3 = 0 ;
9520 wxString *arg4 = 0 ;
9521 wxDateTime arg5 ;
9522 wxFSFile *result = 0 ;
9523 wxPyInputStream *temp1 ;
9524 bool temp2 = false ;
9525 bool temp3 = false ;
9526 bool temp4 = false ;
9527 void *argp5 ;
9528 int res5 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 PyObject * obj2 = 0 ;
9532 PyObject * obj3 = 0 ;
9533 PyObject * obj4 = 0 ;
9534 char * kwnames[] = {
9535 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9536 };
9537
9538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9539 {
9540 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9541 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9542 } else {
9543 PyErr_Clear(); // clear the failure of the wxPyConvert above
9544 arg1 = wxPyCBInputStream_create(obj0, true);
9545 if (arg1 == NULL) {
9546 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9547 SWIG_fail;
9548 }
9549 }
9550 }
9551 {
9552 arg2 = wxString_in_helper(obj1);
9553 if (arg2 == NULL) SWIG_fail;
9554 temp2 = true;
9555 }
9556 {
9557 arg3 = wxString_in_helper(obj2);
9558 if (arg3 == NULL) SWIG_fail;
9559 temp3 = true;
9560 }
9561 {
9562 arg4 = wxString_in_helper(obj3);
9563 if (arg4 == NULL) SWIG_fail;
9564 temp4 = true;
9565 }
9566 {
9567 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9568 if (!SWIG_IsOK(res5)) {
9569 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9570 }
9571 if (!argp5) {
9572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9573 } else {
9574 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9575 arg5 = *temp;
9576 if (SWIG_IsNewObj(res5)) delete temp;
9577 }
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 {
9586 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9587 }
9588 {
9589 if (temp2)
9590 delete arg2;
9591 }
9592 {
9593 if (temp3)
9594 delete arg3;
9595 }
9596 {
9597 if (temp4)
9598 delete arg4;
9599 }
9600 return resultobj;
9601 fail:
9602 {
9603 if (temp2)
9604 delete arg2;
9605 }
9606 {
9607 if (temp3)
9608 delete arg3;
9609 }
9610 {
9611 if (temp4)
9612 delete arg4;
9613 }
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxFSFile *arg1 = (wxFSFile *) 0 ;
9621 void *argp1 = 0 ;
9622 int res1 = 0 ;
9623 PyObject *swig_obj[1] ;
9624
9625 if (!args) SWIG_fail;
9626 swig_obj[0] = args;
9627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9628 if (!SWIG_IsOK(res1)) {
9629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9630 }
9631 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 delete arg1;
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_Py_Void();
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9647 PyObject *resultobj = 0;
9648 wxFSFile *arg1 = (wxFSFile *) 0 ;
9649 wxInputStream *result = 0 ;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 PyObject *swig_obj[1] ;
9653
9654 if (!args) SWIG_fail;
9655 swig_obj[0] = args;
9656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9659 }
9660 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = (wxInputStream *)(arg1)->GetStream();
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 {
9668 wxPyInputStream * _ptr = NULL;
9669
9670 if (result) {
9671 _ptr = new wxPyInputStream(result);
9672 }
9673 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9674 }
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9682 PyObject *resultobj = 0;
9683 wxFSFile *arg1 = (wxFSFile *) 0 ;
9684 wxString *result = 0 ;
9685 void *argp1 = 0 ;
9686 int res1 = 0 ;
9687 PyObject *swig_obj[1] ;
9688
9689 if (!args) SWIG_fail;
9690 swig_obj[0] = args;
9691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9692 if (!SWIG_IsOK(res1)) {
9693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9694 }
9695 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9696 {
9697 PyThreadState* __tstate = wxPyBeginAllowThreads();
9698 {
9699 wxString const &_result_ref = (arg1)->GetMimeType();
9700 result = (wxString *) &_result_ref;
9701 }
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 #if wxUSE_UNICODE
9707 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9708 #else
9709 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9710 #endif
9711 }
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9719 PyObject *resultobj = 0;
9720 wxFSFile *arg1 = (wxFSFile *) 0 ;
9721 wxString *result = 0 ;
9722 void *argp1 = 0 ;
9723 int res1 = 0 ;
9724 PyObject *swig_obj[1] ;
9725
9726 if (!args) SWIG_fail;
9727 swig_obj[0] = args;
9728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9731 }
9732 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 {
9736 wxString const &_result_ref = (arg1)->GetLocation();
9737 result = (wxString *) &_result_ref;
9738 }
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 {
9743 #if wxUSE_UNICODE
9744 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9745 #else
9746 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9747 #endif
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 PyObject *resultobj = 0;
9757 wxFSFile *arg1 = (wxFSFile *) 0 ;
9758 wxString *result = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 {
9773 wxString const &_result_ref = (arg1)->GetAnchor();
9774 result = (wxString *) &_result_ref;
9775 }
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 {
9780 #if wxUSE_UNICODE
9781 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9782 #else
9783 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9784 #endif
9785 }
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *resultobj = 0;
9794 wxFSFile *arg1 = (wxFSFile *) 0 ;
9795 wxDateTime result;
9796 void *argp1 = 0 ;
9797 int res1 = 0 ;
9798 PyObject *swig_obj[1] ;
9799
9800 if (!args) SWIG_fail;
9801 swig_obj[0] = args;
9802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9805 }
9806 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = (arg1)->GetModificationTime();
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9821 PyObject *obj;
9822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9823 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9824 return SWIG_Py_Void();
9825 }
9826
9827 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9828 return SWIG_Python_InitShadowInstance(args);
9829 }
9830
9831 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *obj;
9833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9834 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9835 return SWIG_Py_Void();
9836 }
9837
9838 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9839 PyObject *resultobj = 0;
9840 wxPyFileSystemHandler *result = 0 ;
9841
9842 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9846 wxPyEndAllowThreads(__tstate);
9847 if (PyErr_Occurred()) SWIG_fail;
9848 }
9849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9850 return resultobj;
9851 fail:
9852 return NULL;
9853 }
9854
9855
9856 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj = 0;
9858 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9859 PyObject *arg2 = (PyObject *) 0 ;
9860 PyObject *arg3 = (PyObject *) 0 ;
9861 void *argp1 = 0 ;
9862 int res1 = 0 ;
9863 PyObject * obj0 = 0 ;
9864 PyObject * obj1 = 0 ;
9865 PyObject * obj2 = 0 ;
9866 char * kwnames[] = {
9867 (char *) "self",(char *) "self",(char *) "_class", NULL
9868 };
9869
9870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9874 }
9875 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9876 arg2 = obj1;
9877 arg3 = obj2;
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 (arg1)->_setCallbackInfo(arg2,arg3);
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_Py_Void();
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj = 0;
9893 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9894 wxString *arg2 = 0 ;
9895 bool result;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 bool temp2 = false ;
9899 PyObject * obj0 = 0 ;
9900 PyObject * obj1 = 0 ;
9901 char * kwnames[] = {
9902 (char *) "self",(char *) "location", NULL
9903 };
9904
9905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9909 }
9910 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9911 {
9912 arg2 = wxString_in_helper(obj1);
9913 if (arg2 == NULL) SWIG_fail;
9914 temp2 = true;
9915 }
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9924 }
9925 {
9926 if (temp2)
9927 delete arg2;
9928 }
9929 return resultobj;
9930 fail:
9931 {
9932 if (temp2)
9933 delete arg2;
9934 }
9935 return NULL;
9936 }
9937
9938
9939 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9940 PyObject *resultobj = 0;
9941 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9942 wxFileSystem *arg2 = 0 ;
9943 wxString *arg3 = 0 ;
9944 wxFSFile *result = 0 ;
9945 void *argp1 = 0 ;
9946 int res1 = 0 ;
9947 void *argp2 = 0 ;
9948 int res2 = 0 ;
9949 bool temp3 = false ;
9950 PyObject * obj0 = 0 ;
9951 PyObject * obj1 = 0 ;
9952 PyObject * obj2 = 0 ;
9953 char * kwnames[] = {
9954 (char *) "self",(char *) "fs",(char *) "location", NULL
9955 };
9956
9957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9961 }
9962 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9963 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9964 if (!SWIG_IsOK(res2)) {
9965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9966 }
9967 if (!argp2) {
9968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9969 }
9970 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9971 {
9972 arg3 = wxString_in_helper(obj2);
9973 if (arg3 == NULL) SWIG_fail;
9974 temp3 = true;
9975 }
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9984 }
9985 {
9986 if (temp3)
9987 delete arg3;
9988 }
9989 return resultobj;
9990 fail:
9991 {
9992 if (temp3)
9993 delete arg3;
9994 }
9995 return NULL;
9996 }
9997
9998
9999 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10000 PyObject *resultobj = 0;
10001 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10002 wxString *arg2 = 0 ;
10003 int arg3 = (int) 0 ;
10004 wxString result;
10005 void *argp1 = 0 ;
10006 int res1 = 0 ;
10007 bool temp2 = false ;
10008 int val3 ;
10009 int ecode3 = 0 ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 PyObject * obj2 = 0 ;
10013 char * kwnames[] = {
10014 (char *) "self",(char *) "spec",(char *) "flags", NULL
10015 };
10016
10017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10019 if (!SWIG_IsOK(res1)) {
10020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10021 }
10022 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10023 {
10024 arg2 = wxString_in_helper(obj1);
10025 if (arg2 == NULL) SWIG_fail;
10026 temp2 = true;
10027 }
10028 if (obj2) {
10029 ecode3 = SWIG_AsVal_int(obj2, &val3);
10030 if (!SWIG_IsOK(ecode3)) {
10031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10032 }
10033 arg3 = static_cast< int >(val3);
10034 }
10035 {
10036 PyThreadState* __tstate = wxPyBeginAllowThreads();
10037 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 {
10042 #if wxUSE_UNICODE
10043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10044 #else
10045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10046 #endif
10047 }
10048 {
10049 if (temp2)
10050 delete arg2;
10051 }
10052 return resultobj;
10053 fail:
10054 {
10055 if (temp2)
10056 delete arg2;
10057 }
10058 return NULL;
10059 }
10060
10061
10062 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10063 PyObject *resultobj = 0;
10064 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10065 wxString result;
10066 void *argp1 = 0 ;
10067 int res1 = 0 ;
10068 PyObject *swig_obj[1] ;
10069
10070 if (!args) SWIG_fail;
10071 swig_obj[0] = args;
10072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10073 if (!SWIG_IsOK(res1)) {
10074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10075 }
10076 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = (arg1)->FindNext();
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 #if wxUSE_UNICODE
10085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10086 #else
10087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10088 #endif
10089 }
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj = 0;
10098 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 wxString result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 bool temp2 = false ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "self",(char *) "location", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10112 if (!SWIG_IsOK(res1)) {
10113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10114 }
10115 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10116 {
10117 arg2 = wxString_in_helper(obj1);
10118 if (arg2 == NULL) SWIG_fail;
10119 temp2 = true;
10120 }
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 result = (arg1)->GetProtocol((wxString const &)*arg2);
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 {
10128 #if wxUSE_UNICODE
10129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10130 #else
10131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10132 #endif
10133 }
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return resultobj;
10139 fail:
10140 {
10141 if (temp2)
10142 delete arg2;
10143 }
10144 return NULL;
10145 }
10146
10147
10148 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10149 PyObject *resultobj = 0;
10150 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10151 wxString *arg2 = 0 ;
10152 wxString result;
10153 void *argp1 = 0 ;
10154 int res1 = 0 ;
10155 bool temp2 = false ;
10156 PyObject * obj0 = 0 ;
10157 PyObject * obj1 = 0 ;
10158 char * kwnames[] = {
10159 (char *) "self",(char *) "location", NULL
10160 };
10161
10162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10164 if (!SWIG_IsOK(res1)) {
10165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10166 }
10167 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10168 {
10169 arg2 = wxString_in_helper(obj1);
10170 if (arg2 == NULL) SWIG_fail;
10171 temp2 = true;
10172 }
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 {
10180 #if wxUSE_UNICODE
10181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10182 #else
10183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10184 #endif
10185 }
10186 {
10187 if (temp2)
10188 delete arg2;
10189 }
10190 return resultobj;
10191 fail:
10192 {
10193 if (temp2)
10194 delete arg2;
10195 }
10196 return NULL;
10197 }
10198
10199
10200 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj = 0;
10202 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10203 wxString *arg2 = 0 ;
10204 wxString result;
10205 void *argp1 = 0 ;
10206 int res1 = 0 ;
10207 bool temp2 = false ;
10208 PyObject * obj0 = 0 ;
10209 PyObject * obj1 = 0 ;
10210 char * kwnames[] = {
10211 (char *) "self",(char *) "location", NULL
10212 };
10213
10214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10216 if (!SWIG_IsOK(res1)) {
10217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10218 }
10219 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10220 {
10221 arg2 = wxString_in_helper(obj1);
10222 if (arg2 == NULL) SWIG_fail;
10223 temp2 = true;
10224 }
10225 {
10226 PyThreadState* __tstate = wxPyBeginAllowThreads();
10227 result = (arg1)->GetAnchor((wxString const &)*arg2);
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 {
10232 #if wxUSE_UNICODE
10233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10234 #else
10235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10236 #endif
10237 }
10238 {
10239 if (temp2)
10240 delete arg2;
10241 }
10242 return resultobj;
10243 fail:
10244 {
10245 if (temp2)
10246 delete arg2;
10247 }
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj = 0;
10254 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10255 wxString *arg2 = 0 ;
10256 wxString result;
10257 void *argp1 = 0 ;
10258 int res1 = 0 ;
10259 bool temp2 = false ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char * kwnames[] = {
10263 (char *) "self",(char *) "location", NULL
10264 };
10265
10266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10270 }
10271 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10272 {
10273 arg2 = wxString_in_helper(obj1);
10274 if (arg2 == NULL) SWIG_fail;
10275 temp2 = true;
10276 }
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 {
10284 #if wxUSE_UNICODE
10285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10286 #else
10287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10288 #endif
10289 }
10290 {
10291 if (temp2)
10292 delete arg2;
10293 }
10294 return resultobj;
10295 fail:
10296 {
10297 if (temp2)
10298 delete arg2;
10299 }
10300 return NULL;
10301 }
10302
10303
10304 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10305 PyObject *resultobj = 0;
10306 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10307 wxString *arg2 = 0 ;
10308 wxString result;
10309 void *argp1 = 0 ;
10310 int res1 = 0 ;
10311 bool temp2 = false ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 char * kwnames[] = {
10315 (char *) "self",(char *) "location", NULL
10316 };
10317
10318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10320 if (!SWIG_IsOK(res1)) {
10321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10322 }
10323 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10324 {
10325 arg2 = wxString_in_helper(obj1);
10326 if (arg2 == NULL) SWIG_fail;
10327 temp2 = true;
10328 }
10329 {
10330 PyThreadState* __tstate = wxPyBeginAllowThreads();
10331 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 #if wxUSE_UNICODE
10337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10338 #else
10339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10340 #endif
10341 }
10342 {
10343 if (temp2)
10344 delete arg2;
10345 }
10346 return resultobj;
10347 fail:
10348 {
10349 if (temp2)
10350 delete arg2;
10351 }
10352 return NULL;
10353 }
10354
10355
10356 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10357 PyObject *obj;
10358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10359 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10360 return SWIG_Py_Void();
10361 }
10362
10363 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10364 return SWIG_Python_InitShadowInstance(args);
10365 }
10366
10367 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10368 PyObject *resultobj = 0;
10369 wxFileSystem *result = 0 ;
10370
10371 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 result = (wxFileSystem *)new wxFileSystem();
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 {
10379 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10380 }
10381 return resultobj;
10382 fail:
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10388 PyObject *resultobj = 0;
10389 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 PyObject *swig_obj[1] ;
10393
10394 if (!args) SWIG_fail;
10395 swig_obj[0] = args;
10396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10399 }
10400 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10401 {
10402 PyThreadState* __tstate = wxPyBeginAllowThreads();
10403 delete arg1;
10404
10405 wxPyEndAllowThreads(__tstate);
10406 if (PyErr_Occurred()) SWIG_fail;
10407 }
10408 resultobj = SWIG_Py_Void();
10409 return resultobj;
10410 fail:
10411 return NULL;
10412 }
10413
10414
10415 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10416 PyObject *resultobj = 0;
10417 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10418 wxString *arg2 = 0 ;
10419 bool arg3 = (bool) false ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 bool temp2 = false ;
10423 bool val3 ;
10424 int ecode3 = 0 ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 PyObject * obj2 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10436 }
10437 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10438 {
10439 arg2 = wxString_in_helper(obj1);
10440 if (arg2 == NULL) SWIG_fail;
10441 temp2 = true;
10442 }
10443 if (obj2) {
10444 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10445 if (!SWIG_IsOK(ecode3)) {
10446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10447 }
10448 arg3 = static_cast< bool >(val3);
10449 }
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 resultobj = SWIG_Py_Void();
10457 {
10458 if (temp2)
10459 delete arg2;
10460 }
10461 return resultobj;
10462 fail:
10463 {
10464 if (temp2)
10465 delete arg2;
10466 }
10467 return NULL;
10468 }
10469
10470
10471 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10472 PyObject *resultobj = 0;
10473 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10474 wxString result;
10475 void *argp1 = 0 ;
10476 int res1 = 0 ;
10477 PyObject *swig_obj[1] ;
10478
10479 if (!args) SWIG_fail;
10480 swig_obj[0] = args;
10481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10482 if (!SWIG_IsOK(res1)) {
10483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10484 }
10485 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10486 {
10487 PyThreadState* __tstate = wxPyBeginAllowThreads();
10488 result = (arg1)->GetPath();
10489 wxPyEndAllowThreads(__tstate);
10490 if (PyErr_Occurred()) SWIG_fail;
10491 }
10492 {
10493 #if wxUSE_UNICODE
10494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10495 #else
10496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10497 #endif
10498 }
10499 return resultobj;
10500 fail:
10501 return NULL;
10502 }
10503
10504
10505 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10506 PyObject *resultobj = 0;
10507 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10508 wxString *arg2 = 0 ;
10509 wxFSFile *result = 0 ;
10510 void *argp1 = 0 ;
10511 int res1 = 0 ;
10512 bool temp2 = false ;
10513 PyObject * obj0 = 0 ;
10514 PyObject * obj1 = 0 ;
10515 char * kwnames[] = {
10516 (char *) "self",(char *) "location", NULL
10517 };
10518
10519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10521 if (!SWIG_IsOK(res1)) {
10522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10523 }
10524 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10525 {
10526 arg2 = wxString_in_helper(obj1);
10527 if (arg2 == NULL) SWIG_fail;
10528 temp2 = true;
10529 }
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10533 wxPyEndAllowThreads(__tstate);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 {
10537 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10538 }
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj = 0;
10555 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10556 wxString *arg2 = 0 ;
10557 int arg3 = (int) 0 ;
10558 wxString result;
10559 void *argp1 = 0 ;
10560 int res1 = 0 ;
10561 bool temp2 = false ;
10562 int val3 ;
10563 int ecode3 = 0 ;
10564 PyObject * obj0 = 0 ;
10565 PyObject * obj1 = 0 ;
10566 PyObject * obj2 = 0 ;
10567 char * kwnames[] = {
10568 (char *) "self",(char *) "spec",(char *) "flags", NULL
10569 };
10570
10571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10573 if (!SWIG_IsOK(res1)) {
10574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10575 }
10576 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 if (obj2) {
10583 ecode3 = SWIG_AsVal_int(obj2, &val3);
10584 if (!SWIG_IsOK(ecode3)) {
10585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10586 }
10587 arg3 = static_cast< int >(val3);
10588 }
10589 {
10590 PyThreadState* __tstate = wxPyBeginAllowThreads();
10591 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10592 wxPyEndAllowThreads(__tstate);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 {
10596 #if wxUSE_UNICODE
10597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10598 #else
10599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10600 #endif
10601 }
10602 {
10603 if (temp2)
10604 delete arg2;
10605 }
10606 return resultobj;
10607 fail:
10608 {
10609 if (temp2)
10610 delete arg2;
10611 }
10612 return NULL;
10613 }
10614
10615
10616 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10617 PyObject *resultobj = 0;
10618 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10619 wxString result;
10620 void *argp1 = 0 ;
10621 int res1 = 0 ;
10622 PyObject *swig_obj[1] ;
10623
10624 if (!args) SWIG_fail;
10625 swig_obj[0] = args;
10626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10627 if (!SWIG_IsOK(res1)) {
10628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10629 }
10630 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = (arg1)->FindNext();
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 #if wxUSE_UNICODE
10639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10640 #else
10641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10642 #endif
10643 }
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj = 0;
10652 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject * obj0 = 0 ;
10656 char * kwnames[] = {
10657 (char *) "handler", NULL
10658 };
10659
10660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10662 if (!SWIG_IsOK(res1)) {
10663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10664 }
10665 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 wxFileSystem::AddHandler(arg1);
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_Py_Void();
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10680 PyObject *resultobj = 0;
10681
10682 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 wxFileSystem::CleanUpHandlers();
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 resultobj = SWIG_Py_Void();
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj = 0;
10698 wxString *arg1 = 0 ;
10699 wxString result;
10700 bool temp1 = false ;
10701 PyObject * obj0 = 0 ;
10702 char * kwnames[] = {
10703 (char *) "filename", NULL
10704 };
10705
10706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10707 {
10708 arg1 = wxString_in_helper(obj0);
10709 if (arg1 == NULL) SWIG_fail;
10710 temp1 = true;
10711 }
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 {
10719 #if wxUSE_UNICODE
10720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10721 #else
10722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10723 #endif
10724 }
10725 {
10726 if (temp1)
10727 delete arg1;
10728 }
10729 return resultobj;
10730 fail:
10731 {
10732 if (temp1)
10733 delete arg1;
10734 }
10735 return NULL;
10736 }
10737
10738
10739 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj = 0;
10741 wxString *arg1 = 0 ;
10742 wxString result;
10743 bool temp1 = false ;
10744 PyObject * obj0 = 0 ;
10745 char * kwnames[] = {
10746 (char *) "url", NULL
10747 };
10748
10749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10750 {
10751 arg1 = wxString_in_helper(obj0);
10752 if (arg1 == NULL) SWIG_fail;
10753 temp1 = true;
10754 }
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10758 wxPyEndAllowThreads(__tstate);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 #if wxUSE_UNICODE
10763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10764 #else
10765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10766 #endif
10767 }
10768 {
10769 if (temp1)
10770 delete arg1;
10771 }
10772 return resultobj;
10773 fail:
10774 {
10775 if (temp1)
10776 delete arg1;
10777 }
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10783 PyObject *obj;
10784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10785 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10786 return SWIG_Py_Void();
10787 }
10788
10789 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10790 return SWIG_Python_InitShadowInstance(args);
10791 }
10792
10793 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *resultobj = 0;
10795 wxInternetFSHandler *result = 0 ;
10796
10797 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10798 {
10799 PyThreadState* __tstate = wxPyBeginAllowThreads();
10800 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj = 0;
10813 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10814 wxString *arg2 = 0 ;
10815 bool result;
10816 void *argp1 = 0 ;
10817 int res1 = 0 ;
10818 bool temp2 = false ;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 char * kwnames[] = {
10822 (char *) "self",(char *) "location", NULL
10823 };
10824
10825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10827 if (!SWIG_IsOK(res1)) {
10828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10829 }
10830 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10831 {
10832 arg2 = wxString_in_helper(obj1);
10833 if (arg2 == NULL) SWIG_fail;
10834 temp2 = true;
10835 }
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 {
10843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10844 }
10845 {
10846 if (temp2)
10847 delete arg2;
10848 }
10849 return resultobj;
10850 fail:
10851 {
10852 if (temp2)
10853 delete arg2;
10854 }
10855 return NULL;
10856 }
10857
10858
10859 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10860 PyObject *resultobj = 0;
10861 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10862 wxFileSystem *arg2 = 0 ;
10863 wxString *arg3 = 0 ;
10864 wxFSFile *result = 0 ;
10865 void *argp1 = 0 ;
10866 int res1 = 0 ;
10867 void *argp2 = 0 ;
10868 int res2 = 0 ;
10869 bool temp3 = false ;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 PyObject * obj2 = 0 ;
10873 char * kwnames[] = {
10874 (char *) "self",(char *) "fs",(char *) "location", NULL
10875 };
10876
10877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10879 if (!SWIG_IsOK(res1)) {
10880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10881 }
10882 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10884 if (!SWIG_IsOK(res2)) {
10885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10886 }
10887 if (!argp2) {
10888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10889 }
10890 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10891 {
10892 arg3 = wxString_in_helper(obj2);
10893 if (arg3 == NULL) SWIG_fail;
10894 temp3 = true;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10899 wxPyEndAllowThreads(__tstate);
10900 if (PyErr_Occurred()) SWIG_fail;
10901 }
10902 {
10903 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10904 }
10905 {
10906 if (temp3)
10907 delete arg3;
10908 }
10909 return resultobj;
10910 fail:
10911 {
10912 if (temp3)
10913 delete arg3;
10914 }
10915 return NULL;
10916 }
10917
10918
10919 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10920 PyObject *obj;
10921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10922 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10923 return SWIG_Py_Void();
10924 }
10925
10926 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10927 return SWIG_Python_InitShadowInstance(args);
10928 }
10929
10930 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10931 PyObject *resultobj = 0;
10932 wxZipFSHandler *result = 0 ;
10933
10934 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 result = (wxZipFSHandler *)new wxZipFSHandler();
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10951 wxString *arg2 = 0 ;
10952 bool result;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 bool temp2 = false ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char * kwnames[] = {
10959 (char *) "self",(char *) "location", NULL
10960 };
10961
10962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10964 if (!SWIG_IsOK(res1)) {
10965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10966 }
10967 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10968 {
10969 arg2 = wxString_in_helper(obj1);
10970 if (arg2 == NULL) SWIG_fail;
10971 temp2 = true;
10972 }
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 {
10980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10981 }
10982 {
10983 if (temp2)
10984 delete arg2;
10985 }
10986 return resultobj;
10987 fail:
10988 {
10989 if (temp2)
10990 delete arg2;
10991 }
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj = 0;
10998 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10999 wxFileSystem *arg2 = 0 ;
11000 wxString *arg3 = 0 ;
11001 wxFSFile *result = 0 ;
11002 void *argp1 = 0 ;
11003 int res1 = 0 ;
11004 void *argp2 = 0 ;
11005 int res2 = 0 ;
11006 bool temp3 = false ;
11007 PyObject * obj0 = 0 ;
11008 PyObject * obj1 = 0 ;
11009 PyObject * obj2 = 0 ;
11010 char * kwnames[] = {
11011 (char *) "self",(char *) "fs",(char *) "location", NULL
11012 };
11013
11014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11016 if (!SWIG_IsOK(res1)) {
11017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11018 }
11019 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11021 if (!SWIG_IsOK(res2)) {
11022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11023 }
11024 if (!argp2) {
11025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11026 }
11027 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11028 {
11029 arg3 = wxString_in_helper(obj2);
11030 if (arg3 == NULL) SWIG_fail;
11031 temp3 = true;
11032 }
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 {
11040 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11041 }
11042 {
11043 if (temp3)
11044 delete arg3;
11045 }
11046 return resultobj;
11047 fail:
11048 {
11049 if (temp3)
11050 delete arg3;
11051 }
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj = 0;
11058 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11059 wxString *arg2 = 0 ;
11060 int arg3 = (int) 0 ;
11061 wxString result;
11062 void *argp1 = 0 ;
11063 int res1 = 0 ;
11064 bool temp2 = false ;
11065 int val3 ;
11066 int ecode3 = 0 ;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 PyObject * obj2 = 0 ;
11070 char * kwnames[] = {
11071 (char *) "self",(char *) "spec",(char *) "flags", NULL
11072 };
11073
11074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11076 if (!SWIG_IsOK(res1)) {
11077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11078 }
11079 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11080 {
11081 arg2 = wxString_in_helper(obj1);
11082 if (arg2 == NULL) SWIG_fail;
11083 temp2 = true;
11084 }
11085 if (obj2) {
11086 ecode3 = SWIG_AsVal_int(obj2, &val3);
11087 if (!SWIG_IsOK(ecode3)) {
11088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11089 }
11090 arg3 = static_cast< int >(val3);
11091 }
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 #if wxUSE_UNICODE
11100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11101 #else
11102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11103 #endif
11104 }
11105 {
11106 if (temp2)
11107 delete arg2;
11108 }
11109 return resultobj;
11110 fail:
11111 {
11112 if (temp2)
11113 delete arg2;
11114 }
11115 return NULL;
11116 }
11117
11118
11119 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11120 PyObject *resultobj = 0;
11121 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11122 wxString result;
11123 void *argp1 = 0 ;
11124 int res1 = 0 ;
11125 PyObject *swig_obj[1] ;
11126
11127 if (!args) SWIG_fail;
11128 swig_obj[0] = args;
11129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11130 if (!SWIG_IsOK(res1)) {
11131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11132 }
11133 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = (arg1)->FindNext();
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 {
11141 #if wxUSE_UNICODE
11142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11143 #else
11144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11145 #endif
11146 }
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11154 PyObject *obj;
11155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11156 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11157 return SWIG_Py_Void();
11158 }
11159
11160 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11161 return SWIG_Python_InitShadowInstance(args);
11162 }
11163
11164 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj = 0;
11166 wxString *arg1 = 0 ;
11167 wxImage *arg2 = 0 ;
11168 long arg3 ;
11169 bool temp1 = false ;
11170 void *argp2 = 0 ;
11171 int res2 = 0 ;
11172 long val3 ;
11173 int ecode3 = 0 ;
11174 PyObject * obj0 = 0 ;
11175 PyObject * obj1 = 0 ;
11176 PyObject * obj2 = 0 ;
11177 char * kwnames[] = {
11178 (char *) "filename",(char *) "image",(char *) "type", NULL
11179 };
11180
11181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11182 {
11183 arg1 = wxString_in_helper(obj0);
11184 if (arg1 == NULL) SWIG_fail;
11185 temp1 = true;
11186 }
11187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11188 if (!SWIG_IsOK(res2)) {
11189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11190 }
11191 if (!argp2) {
11192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11193 }
11194 arg2 = reinterpret_cast< wxImage * >(argp2);
11195 ecode3 = SWIG_AsVal_long(obj2, &val3);
11196 if (!SWIG_IsOK(ecode3)) {
11197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11198 }
11199 arg3 = static_cast< long >(val3);
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 resultobj = SWIG_Py_Void();
11207 {
11208 if (temp1)
11209 delete arg1;
11210 }
11211 return resultobj;
11212 fail:
11213 {
11214 if (temp1)
11215 delete arg1;
11216 }
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj = 0;
11223 wxString *arg1 = 0 ;
11224 wxBitmap *arg2 = 0 ;
11225 long arg3 ;
11226 bool temp1 = false ;
11227 void *argp2 = 0 ;
11228 int res2 = 0 ;
11229 long val3 ;
11230 int ecode3 = 0 ;
11231 PyObject * obj0 = 0 ;
11232 PyObject * obj1 = 0 ;
11233 PyObject * obj2 = 0 ;
11234 char * kwnames[] = {
11235 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11236 };
11237
11238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11239 {
11240 arg1 = wxString_in_helper(obj0);
11241 if (arg1 == NULL) SWIG_fail;
11242 temp1 = true;
11243 }
11244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11245 if (!SWIG_IsOK(res2)) {
11246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11247 }
11248 if (!argp2) {
11249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11250 }
11251 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11252 ecode3 = SWIG_AsVal_long(obj2, &val3);
11253 if (!SWIG_IsOK(ecode3)) {
11254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11255 }
11256 arg3 = static_cast< long >(val3);
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 resultobj = SWIG_Py_Void();
11264 {
11265 if (temp1)
11266 delete arg1;
11267 }
11268 return resultobj;
11269 fail:
11270 {
11271 if (temp1)
11272 delete arg1;
11273 }
11274 return NULL;
11275 }
11276
11277
11278 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj = 0;
11280 wxString *arg1 = 0 ;
11281 PyObject *arg2 = (PyObject *) 0 ;
11282 bool temp1 = false ;
11283 PyObject * obj0 = 0 ;
11284 PyObject * obj1 = 0 ;
11285 char * kwnames[] = {
11286 (char *) "filename",(char *) "data", NULL
11287 };
11288
11289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11290 {
11291 arg1 = wxString_in_helper(obj0);
11292 if (arg1 == NULL) SWIG_fail;
11293 temp1 = true;
11294 }
11295 arg2 = obj1;
11296 {
11297 PyThreadState* __tstate = wxPyBeginAllowThreads();
11298 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 resultobj = SWIG_Py_Void();
11303 {
11304 if (temp1)
11305 delete arg1;
11306 }
11307 return resultobj;
11308 fail:
11309 {
11310 if (temp1)
11311 delete arg1;
11312 }
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11318 PyObject *resultobj = 0;
11319 wxMemoryFSHandler *result = 0 ;
11320
11321 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11329 return resultobj;
11330 fail:
11331 return NULL;
11332 }
11333
11334
11335 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11336 PyObject *resultobj = 0;
11337 wxString *arg1 = 0 ;
11338 bool temp1 = false ;
11339 PyObject * obj0 = 0 ;
11340 char * kwnames[] = {
11341 (char *) "filename", NULL
11342 };
11343
11344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11345 {
11346 arg1 = wxString_in_helper(obj0);
11347 if (arg1 == NULL) SWIG_fail;
11348 temp1 = true;
11349 }
11350 {
11351 PyThreadState* __tstate = wxPyBeginAllowThreads();
11352 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11353 wxPyEndAllowThreads(__tstate);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 resultobj = SWIG_Py_Void();
11357 {
11358 if (temp1)
11359 delete arg1;
11360 }
11361 return resultobj;
11362 fail:
11363 {
11364 if (temp1)
11365 delete arg1;
11366 }
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj = 0;
11373 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11374 wxString *arg2 = 0 ;
11375 bool result;
11376 void *argp1 = 0 ;
11377 int res1 = 0 ;
11378 bool temp2 = false ;
11379 PyObject * obj0 = 0 ;
11380 PyObject * obj1 = 0 ;
11381 char * kwnames[] = {
11382 (char *) "self",(char *) "location", NULL
11383 };
11384
11385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11387 if (!SWIG_IsOK(res1)) {
11388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11389 }
11390 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11391 {
11392 arg2 = wxString_in_helper(obj1);
11393 if (arg2 == NULL) SWIG_fail;
11394 temp2 = true;
11395 }
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 {
11403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404 }
11405 {
11406 if (temp2)
11407 delete arg2;
11408 }
11409 return resultobj;
11410 fail:
11411 {
11412 if (temp2)
11413 delete arg2;
11414 }
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11420 PyObject *resultobj = 0;
11421 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11422 wxFileSystem *arg2 = 0 ;
11423 wxString *arg3 = 0 ;
11424 wxFSFile *result = 0 ;
11425 void *argp1 = 0 ;
11426 int res1 = 0 ;
11427 void *argp2 = 0 ;
11428 int res2 = 0 ;
11429 bool temp3 = false ;
11430 PyObject * obj0 = 0 ;
11431 PyObject * obj1 = 0 ;
11432 PyObject * obj2 = 0 ;
11433 char * kwnames[] = {
11434 (char *) "self",(char *) "fs",(char *) "location", NULL
11435 };
11436
11437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11439 if (!SWIG_IsOK(res1)) {
11440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11441 }
11442 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11443 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11444 if (!SWIG_IsOK(res2)) {
11445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11446 }
11447 if (!argp2) {
11448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11449 }
11450 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11451 {
11452 arg3 = wxString_in_helper(obj2);
11453 if (arg3 == NULL) SWIG_fail;
11454 temp3 = true;
11455 }
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 {
11463 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11464 }
11465 {
11466 if (temp3)
11467 delete arg3;
11468 }
11469 return resultobj;
11470 fail:
11471 {
11472 if (temp3)
11473 delete arg3;
11474 }
11475 return NULL;
11476 }
11477
11478
11479 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11480 PyObject *resultobj = 0;
11481 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11482 wxString *arg2 = 0 ;
11483 int arg3 = (int) 0 ;
11484 wxString result;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 bool temp2 = false ;
11488 int val3 ;
11489 int ecode3 = 0 ;
11490 PyObject * obj0 = 0 ;
11491 PyObject * obj1 = 0 ;
11492 PyObject * obj2 = 0 ;
11493 char * kwnames[] = {
11494 (char *) "self",(char *) "spec",(char *) "flags", NULL
11495 };
11496
11497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11499 if (!SWIG_IsOK(res1)) {
11500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11501 }
11502 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11503 {
11504 arg2 = wxString_in_helper(obj1);
11505 if (arg2 == NULL) SWIG_fail;
11506 temp2 = true;
11507 }
11508 if (obj2) {
11509 ecode3 = SWIG_AsVal_int(obj2, &val3);
11510 if (!SWIG_IsOK(ecode3)) {
11511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11512 }
11513 arg3 = static_cast< int >(val3);
11514 }
11515 {
11516 PyThreadState* __tstate = wxPyBeginAllowThreads();
11517 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 {
11522 #if wxUSE_UNICODE
11523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11524 #else
11525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11526 #endif
11527 }
11528 {
11529 if (temp2)
11530 delete arg2;
11531 }
11532 return resultobj;
11533 fail:
11534 {
11535 if (temp2)
11536 delete arg2;
11537 }
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11543 PyObject *resultobj = 0;
11544 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11545 wxString result;
11546 void *argp1 = 0 ;
11547 int res1 = 0 ;
11548 PyObject *swig_obj[1] ;
11549
11550 if (!args) SWIG_fail;
11551 swig_obj[0] = args;
11552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11553 if (!SWIG_IsOK(res1)) {
11554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11555 }
11556 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11557 {
11558 PyThreadState* __tstate = wxPyBeginAllowThreads();
11559 result = (arg1)->FindNext();
11560 wxPyEndAllowThreads(__tstate);
11561 if (PyErr_Occurred()) SWIG_fail;
11562 }
11563 {
11564 #if wxUSE_UNICODE
11565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11566 #else
11567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11568 #endif
11569 }
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11577 PyObject *obj;
11578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11579 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11580 return SWIG_Py_Void();
11581 }
11582
11583 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11584 return SWIG_Python_InitShadowInstance(args);
11585 }
11586
11587 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11588 PyObject *resultobj = 0;
11589 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11590 wxString result;
11591 void *argp1 = 0 ;
11592 int res1 = 0 ;
11593 PyObject *swig_obj[1] ;
11594
11595 if (!args) SWIG_fail;
11596 swig_obj[0] = args;
11597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11600 }
11601 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 result = (arg1)->GetName();
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 #if wxUSE_UNICODE
11610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11611 #else
11612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11613 #endif
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11622 PyObject *resultobj = 0;
11623 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11624 wxString result;
11625 void *argp1 = 0 ;
11626 int res1 = 0 ;
11627 PyObject *swig_obj[1] ;
11628
11629 if (!args) SWIG_fail;
11630 swig_obj[0] = args;
11631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11632 if (!SWIG_IsOK(res1)) {
11633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11634 }
11635 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11636 {
11637 PyThreadState* __tstate = wxPyBeginAllowThreads();
11638 result = (arg1)->GetExtension();
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 #if wxUSE_UNICODE
11644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11645 #else
11646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11647 #endif
11648 }
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11656 PyObject *resultobj = 0;
11657 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11658 long result;
11659 void *argp1 = 0 ;
11660 int res1 = 0 ;
11661 PyObject *swig_obj[1] ;
11662
11663 if (!args) SWIG_fail;
11664 swig_obj[0] = args;
11665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11666 if (!SWIG_IsOK(res1)) {
11667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11668 }
11669 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11670 {
11671 PyThreadState* __tstate = wxPyBeginAllowThreads();
11672 result = (long)(arg1)->GetType();
11673 wxPyEndAllowThreads(__tstate);
11674 if (PyErr_Occurred()) SWIG_fail;
11675 }
11676 resultobj = SWIG_From_long(static_cast< long >(result));
11677 return resultobj;
11678 fail:
11679 return NULL;
11680 }
11681
11682
11683 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11686 wxString result;
11687 void *argp1 = 0 ;
11688 int res1 = 0 ;
11689 PyObject *swig_obj[1] ;
11690
11691 if (!args) SWIG_fail;
11692 swig_obj[0] = args;
11693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11696 }
11697 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (arg1)->GetMimeType();
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 {
11705 #if wxUSE_UNICODE
11706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11707 #else
11708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11709 #endif
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj = 0;
11719 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11720 wxString *arg2 = 0 ;
11721 bool result;
11722 void *argp1 = 0 ;
11723 int res1 = 0 ;
11724 bool temp2 = false ;
11725 PyObject * obj0 = 0 ;
11726 PyObject * obj1 = 0 ;
11727 char * kwnames[] = {
11728 (char *) "self",(char *) "name", NULL
11729 };
11730
11731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11735 }
11736 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11737 {
11738 arg2 = wxString_in_helper(obj1);
11739 if (arg2 == NULL) SWIG_fail;
11740 temp2 = true;
11741 }
11742 {
11743 PyThreadState* __tstate = wxPyBeginAllowThreads();
11744 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11745 wxPyEndAllowThreads(__tstate);
11746 if (PyErr_Occurred()) SWIG_fail;
11747 }
11748 {
11749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11750 }
11751 {
11752 if (temp2)
11753 delete arg2;
11754 }
11755 return resultobj;
11756 fail:
11757 {
11758 if (temp2)
11759 delete arg2;
11760 }
11761 return NULL;
11762 }
11763
11764
11765 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj = 0;
11767 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11768 wxString *arg2 = 0 ;
11769 void *argp1 = 0 ;
11770 int res1 = 0 ;
11771 bool temp2 = false ;
11772 PyObject * obj0 = 0 ;
11773 PyObject * obj1 = 0 ;
11774 char * kwnames[] = {
11775 (char *) "self",(char *) "name", NULL
11776 };
11777
11778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11782 }
11783 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11784 {
11785 arg2 = wxString_in_helper(obj1);
11786 if (arg2 == NULL) SWIG_fail;
11787 temp2 = true;
11788 }
11789 {
11790 PyThreadState* __tstate = wxPyBeginAllowThreads();
11791 (arg1)->SetName((wxString const &)*arg2);
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 resultobj = SWIG_Py_Void();
11796 {
11797 if (temp2)
11798 delete arg2;
11799 }
11800 return resultobj;
11801 fail:
11802 {
11803 if (temp2)
11804 delete arg2;
11805 }
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj = 0;
11812 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11813 wxString *arg2 = 0 ;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 bool temp2 = false ;
11817 PyObject * obj0 = 0 ;
11818 PyObject * obj1 = 0 ;
11819 char * kwnames[] = {
11820 (char *) "self",(char *) "extension", NULL
11821 };
11822
11823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11825 if (!SWIG_IsOK(res1)) {
11826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11827 }
11828 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11829 {
11830 arg2 = wxString_in_helper(obj1);
11831 if (arg2 == NULL) SWIG_fail;
11832 temp2 = true;
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 (arg1)->SetExtension((wxString const &)*arg2);
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 resultobj = SWIG_Py_Void();
11841 {
11842 if (temp2)
11843 delete arg2;
11844 }
11845 return resultobj;
11846 fail:
11847 {
11848 if (temp2)
11849 delete arg2;
11850 }
11851 return NULL;
11852 }
11853
11854
11855 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11856 PyObject *resultobj = 0;
11857 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11858 long arg2 ;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 long val2 ;
11862 int ecode2 = 0 ;
11863 PyObject * obj0 = 0 ;
11864 PyObject * obj1 = 0 ;
11865 char * kwnames[] = {
11866 (char *) "self",(char *) "type", NULL
11867 };
11868
11869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11871 if (!SWIG_IsOK(res1)) {
11872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11873 }
11874 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11875 ecode2 = SWIG_AsVal_long(obj1, &val2);
11876 if (!SWIG_IsOK(ecode2)) {
11877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11878 }
11879 arg2 = static_cast< long >(val2);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 (arg1)->SetType(arg2);
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_Py_Void();
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj = 0;
11895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11896 wxString *arg2 = 0 ;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 bool temp2 = false ;
11900 PyObject * obj0 = 0 ;
11901 PyObject * obj1 = 0 ;
11902 char * kwnames[] = {
11903 (char *) "self",(char *) "mimetype", NULL
11904 };
11905
11906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11908 if (!SWIG_IsOK(res1)) {
11909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11910 }
11911 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11912 {
11913 arg2 = wxString_in_helper(obj1);
11914 if (arg2 == NULL) SWIG_fail;
11915 temp2 = true;
11916 }
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 (arg1)->SetMimeType((wxString const &)*arg2);
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 resultobj = SWIG_Py_Void();
11924 {
11925 if (temp2)
11926 delete arg2;
11927 }
11928 return resultobj;
11929 fail:
11930 {
11931 if (temp2)
11932 delete arg2;
11933 }
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939 PyObject *obj;
11940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11941 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11942 return SWIG_Py_Void();
11943 }
11944
11945 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946 PyObject *resultobj = 0;
11947 wxPyImageHandler *result = 0 ;
11948
11949 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (wxPyImageHandler *)new wxPyImageHandler();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj = 0;
11965 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11966 PyObject *arg2 = (PyObject *) 0 ;
11967 void *argp1 = 0 ;
11968 int res1 = 0 ;
11969 PyObject * obj0 = 0 ;
11970 PyObject * obj1 = 0 ;
11971 char * kwnames[] = {
11972 (char *) "self",(char *) "self", NULL
11973 };
11974
11975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11977 if (!SWIG_IsOK(res1)) {
11978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11979 }
11980 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11981 arg2 = obj1;
11982 {
11983 PyThreadState* __tstate = wxPyBeginAllowThreads();
11984 (arg1)->_SetSelf(arg2);
11985 wxPyEndAllowThreads(__tstate);
11986 if (PyErr_Occurred()) SWIG_fail;
11987 }
11988 resultobj = SWIG_Py_Void();
11989 return resultobj;
11990 fail:
11991 return NULL;
11992 }
11993
11994
11995 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11996 PyObject *obj;
11997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11998 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
11999 return SWIG_Py_Void();
12000 }
12001
12002 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12003 return SWIG_Python_InitShadowInstance(args);
12004 }
12005
12006 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12007 PyObject *resultobj = 0;
12008 wxImageHistogram *result = 0 ;
12009
12010 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (wxImageHistogram *)new wxImageHistogram();
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj = 0;
12026 byte arg1 ;
12027 byte arg2 ;
12028 byte arg3 ;
12029 unsigned long result;
12030 unsigned char val1 ;
12031 int ecode1 = 0 ;
12032 unsigned char val2 ;
12033 int ecode2 = 0 ;
12034 unsigned char val3 ;
12035 int ecode3 = 0 ;
12036 PyObject * obj0 = 0 ;
12037 PyObject * obj1 = 0 ;
12038 PyObject * obj2 = 0 ;
12039 char * kwnames[] = {
12040 (char *) "r",(char *) "g",(char *) "b", NULL
12041 };
12042
12043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12044 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12045 if (!SWIG_IsOK(ecode1)) {
12046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12047 }
12048 arg1 = static_cast< byte >(val1);
12049 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12050 if (!SWIG_IsOK(ecode2)) {
12051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12052 }
12053 arg2 = static_cast< byte >(val2);
12054 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12055 if (!SWIG_IsOK(ecode3)) {
12056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12057 }
12058 arg3 = static_cast< byte >(val3);
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj = 0;
12074 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12075 byte *arg2 = (byte *) 0 ;
12076 byte *arg3 = (byte *) 0 ;
12077 byte *arg4 = (byte *) 0 ;
12078 byte arg5 = (byte) 1 ;
12079 byte arg6 = (byte) 0 ;
12080 byte arg7 = (byte) 0 ;
12081 bool result;
12082 void *argp1 = 0 ;
12083 int res1 = 0 ;
12084 byte temp2 ;
12085 int res2 = SWIG_TMPOBJ ;
12086 byte temp3 ;
12087 int res3 = SWIG_TMPOBJ ;
12088 byte temp4 ;
12089 int res4 = SWIG_TMPOBJ ;
12090 unsigned char val5 ;
12091 int ecode5 = 0 ;
12092 unsigned char val6 ;
12093 int ecode6 = 0 ;
12094 unsigned char val7 ;
12095 int ecode7 = 0 ;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 PyObject * obj2 = 0 ;
12099 PyObject * obj3 = 0 ;
12100 char * kwnames[] = {
12101 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12102 };
12103
12104 arg2 = &temp2;
12105 arg3 = &temp3;
12106 arg4 = &temp4;
12107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12111 }
12112 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12113 if (obj1) {
12114 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12115 if (!SWIG_IsOK(ecode5)) {
12116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12117 }
12118 arg5 = static_cast< byte >(val5);
12119 }
12120 if (obj2) {
12121 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12122 if (!SWIG_IsOK(ecode6)) {
12123 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12124 }
12125 arg6 = static_cast< byte >(val6);
12126 }
12127 if (obj3) {
12128 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12129 if (!SWIG_IsOK(ecode7)) {
12130 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12131 }
12132 arg7 = static_cast< byte >(val7);
12133 }
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12137 wxPyEndAllowThreads(__tstate);
12138 if (PyErr_Occurred()) SWIG_fail;
12139 }
12140 {
12141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12142 }
12143 if (SWIG_IsTmpObj(res2)) {
12144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12145 } else {
12146 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12148 }
12149 if (SWIG_IsTmpObj(res3)) {
12150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12151 } else {
12152 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12154 }
12155 if (SWIG_IsTmpObj(res4)) {
12156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12157 } else {
12158 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12160 }
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj = 0;
12169 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12170 unsigned long arg2 ;
12171 unsigned long result;
12172 void *argp1 = 0 ;
12173 int res1 = 0 ;
12174 unsigned long val2 ;
12175 int ecode2 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 char * kwnames[] = {
12179 (char *) "self",(char *) "key", NULL
12180 };
12181
12182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12186 }
12187 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12188 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12189 if (!SWIG_IsOK(ecode2)) {
12190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12191 }
12192 arg2 = static_cast< unsigned long >(val2);
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12200 return resultobj;
12201 fail:
12202 return NULL;
12203 }
12204
12205
12206 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj = 0;
12208 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12209 byte arg2 ;
12210 byte arg3 ;
12211 byte arg4 ;
12212 unsigned long result;
12213 void *argp1 = 0 ;
12214 int res1 = 0 ;
12215 unsigned char val2 ;
12216 int ecode2 = 0 ;
12217 unsigned char val3 ;
12218 int ecode3 = 0 ;
12219 unsigned char val4 ;
12220 int ecode4 = 0 ;
12221 PyObject * obj0 = 0 ;
12222 PyObject * obj1 = 0 ;
12223 PyObject * obj2 = 0 ;
12224 PyObject * obj3 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12233 }
12234 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12235 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12236 if (!SWIG_IsOK(ecode2)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12238 }
12239 arg2 = static_cast< byte >(val2);
12240 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12241 if (!SWIG_IsOK(ecode3)) {
12242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12243 }
12244 arg3 = static_cast< byte >(val3);
12245 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12246 if (!SWIG_IsOK(ecode4)) {
12247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12248 }
12249 arg4 = static_cast< byte >(val4);
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12266 wxColour *arg2 = 0 ;
12267 unsigned long result;
12268 void *argp1 = 0 ;
12269 int res1 = 0 ;
12270 wxColour temp2 ;
12271 PyObject * obj0 = 0 ;
12272 PyObject * obj1 = 0 ;
12273 char * kwnames[] = {
12274 (char *) "self",(char *) "colour", NULL
12275 };
12276
12277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12279 if (!SWIG_IsOK(res1)) {
12280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12281 }
12282 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12283 {
12284 arg2 = &temp2;
12285 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12286 }
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12301 PyObject *obj;
12302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12303 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12304 return SWIG_Py_Void();
12305 }
12306
12307 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12308 return SWIG_Python_InitShadowInstance(args);
12309 }
12310
12311 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj = 0;
12313 byte arg1 = (byte) 0 ;
12314 byte arg2 = (byte) 0 ;
12315 byte arg3 = (byte) 0 ;
12316 wxImage_RGBValue *result = 0 ;
12317 unsigned char val1 ;
12318 int ecode1 = 0 ;
12319 unsigned char val2 ;
12320 int ecode2 = 0 ;
12321 unsigned char val3 ;
12322 int ecode3 = 0 ;
12323 PyObject * obj0 = 0 ;
12324 PyObject * obj1 = 0 ;
12325 PyObject * obj2 = 0 ;
12326 char * kwnames[] = {
12327 (char *) "r",(char *) "g",(char *) "b", NULL
12328 };
12329
12330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12331 if (obj0) {
12332 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12333 if (!SWIG_IsOK(ecode1)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12335 }
12336 arg1 = static_cast< byte >(val1);
12337 }
12338 if (obj1) {
12339 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12340 if (!SWIG_IsOK(ecode2)) {
12341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12342 }
12343 arg2 = static_cast< byte >(val2);
12344 }
12345 if (obj2) {
12346 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12347 if (!SWIG_IsOK(ecode3)) {
12348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12349 }
12350 arg3 = static_cast< byte >(val3);
12351 }
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12366 PyObject *resultobj = 0;
12367 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12368 byte arg2 ;
12369 void *argp1 = 0 ;
12370 int res1 = 0 ;
12371 unsigned char val2 ;
12372 int ecode2 = 0 ;
12373 PyObject *swig_obj[2] ;
12374
12375 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12377 if (!SWIG_IsOK(res1)) {
12378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12379 }
12380 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12381 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12382 if (!SWIG_IsOK(ecode2)) {
12383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12384 }
12385 arg2 = static_cast< byte >(val2);
12386 if (arg1) (arg1)->red = arg2;
12387
12388 resultobj = SWIG_Py_Void();
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12396 PyObject *resultobj = 0;
12397 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12398 byte result;
12399 void *argp1 = 0 ;
12400 int res1 = 0 ;
12401 PyObject *swig_obj[1] ;
12402
12403 if (!args) SWIG_fail;
12404 swig_obj[0] = args;
12405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12406 if (!SWIG_IsOK(res1)) {
12407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12408 }
12409 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12410 result = (byte) ((arg1)->red);
12411 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12419 PyObject *resultobj = 0;
12420 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12421 byte arg2 ;
12422 void *argp1 = 0 ;
12423 int res1 = 0 ;
12424 unsigned char val2 ;
12425 int ecode2 = 0 ;
12426 PyObject *swig_obj[2] ;
12427
12428 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12430 if (!SWIG_IsOK(res1)) {
12431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12432 }
12433 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12434 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12437 }
12438 arg2 = static_cast< byte >(val2);
12439 if (arg1) (arg1)->green = arg2;
12440
12441 resultobj = SWIG_Py_Void();
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12449 PyObject *resultobj = 0;
12450 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12451 byte result;
12452 void *argp1 = 0 ;
12453 int res1 = 0 ;
12454 PyObject *swig_obj[1] ;
12455
12456 if (!args) SWIG_fail;
12457 swig_obj[0] = args;
12458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12459 if (!SWIG_IsOK(res1)) {
12460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12461 }
12462 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12463 result = (byte) ((arg1)->green);
12464 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12472 PyObject *resultobj = 0;
12473 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12474 byte arg2 ;
12475 void *argp1 = 0 ;
12476 int res1 = 0 ;
12477 unsigned char val2 ;
12478 int ecode2 = 0 ;
12479 PyObject *swig_obj[2] ;
12480
12481 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
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_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12485 }
12486 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12487 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12488 if (!SWIG_IsOK(ecode2)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12490 }
12491 arg2 = static_cast< byte >(val2);
12492 if (arg1) (arg1)->blue = arg2;
12493
12494 resultobj = SWIG_Py_Void();
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12502 PyObject *resultobj = 0;
12503 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12504 byte result;
12505 void *argp1 = 0 ;
12506 int res1 = 0 ;
12507 PyObject *swig_obj[1] ;
12508
12509 if (!args) SWIG_fail;
12510 swig_obj[0] = args;
12511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12512 if (!SWIG_IsOK(res1)) {
12513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12514 }
12515 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12516 result = (byte) ((arg1)->blue);
12517 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12525 PyObject *obj;
12526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12527 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12528 return SWIG_Py_Void();
12529 }
12530
12531 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532 return SWIG_Python_InitShadowInstance(args);
12533 }
12534
12535 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj = 0;
12537 double arg1 = (double) 0.0 ;
12538 double arg2 = (double) 0.0 ;
12539 double arg3 = (double) 0.0 ;
12540 wxImage_HSVValue *result = 0 ;
12541 double val1 ;
12542 int ecode1 = 0 ;
12543 double val2 ;
12544 int ecode2 = 0 ;
12545 double val3 ;
12546 int ecode3 = 0 ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 PyObject * obj2 = 0 ;
12550 char * kwnames[] = {
12551 (char *) "h",(char *) "s",(char *) "v", NULL
12552 };
12553
12554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12555 if (obj0) {
12556 ecode1 = SWIG_AsVal_double(obj0, &val1);
12557 if (!SWIG_IsOK(ecode1)) {
12558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12559 }
12560 arg1 = static_cast< double >(val1);
12561 }
12562 if (obj1) {
12563 ecode2 = SWIG_AsVal_double(obj1, &val2);
12564 if (!SWIG_IsOK(ecode2)) {
12565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12566 }
12567 arg2 = static_cast< double >(val2);
12568 }
12569 if (obj2) {
12570 ecode3 = SWIG_AsVal_double(obj2, &val3);
12571 if (!SWIG_IsOK(ecode3)) {
12572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12573 }
12574 arg3 = static_cast< double >(val3);
12575 }
12576 {
12577 PyThreadState* __tstate = wxPyBeginAllowThreads();
12578 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12579 wxPyEndAllowThreads(__tstate);
12580 if (PyErr_Occurred()) SWIG_fail;
12581 }
12582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12583 return resultobj;
12584 fail:
12585 return NULL;
12586 }
12587
12588
12589 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12590 PyObject *resultobj = 0;
12591 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12592 double arg2 ;
12593 void *argp1 = 0 ;
12594 int res1 = 0 ;
12595 double val2 ;
12596 int ecode2 = 0 ;
12597 PyObject *swig_obj[2] ;
12598
12599 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12601 if (!SWIG_IsOK(res1)) {
12602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12603 }
12604 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12605 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12606 if (!SWIG_IsOK(ecode2)) {
12607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12608 }
12609 arg2 = static_cast< double >(val2);
12610 if (arg1) (arg1)->hue = arg2;
12611
12612 resultobj = SWIG_Py_Void();
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12620 PyObject *resultobj = 0;
12621 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12622 double result;
12623 void *argp1 = 0 ;
12624 int res1 = 0 ;
12625 PyObject *swig_obj[1] ;
12626
12627 if (!args) SWIG_fail;
12628 swig_obj[0] = args;
12629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12630 if (!SWIG_IsOK(res1)) {
12631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12632 }
12633 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12634 result = (double) ((arg1)->hue);
12635 resultobj = SWIG_From_double(static_cast< double >(result));
12636 return resultobj;
12637 fail:
12638 return NULL;
12639 }
12640
12641
12642 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12643 PyObject *resultobj = 0;
12644 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12645 double arg2 ;
12646 void *argp1 = 0 ;
12647 int res1 = 0 ;
12648 double val2 ;
12649 int ecode2 = 0 ;
12650 PyObject *swig_obj[2] ;
12651
12652 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12656 }
12657 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12658 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12659 if (!SWIG_IsOK(ecode2)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12661 }
12662 arg2 = static_cast< double >(val2);
12663 if (arg1) (arg1)->saturation = arg2;
12664
12665 resultobj = SWIG_Py_Void();
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12673 PyObject *resultobj = 0;
12674 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12675 double result;
12676 void *argp1 = 0 ;
12677 int res1 = 0 ;
12678 PyObject *swig_obj[1] ;
12679
12680 if (!args) SWIG_fail;
12681 swig_obj[0] = args;
12682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12683 if (!SWIG_IsOK(res1)) {
12684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12685 }
12686 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12687 result = (double) ((arg1)->saturation);
12688 resultobj = SWIG_From_double(static_cast< double >(result));
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12696 PyObject *resultobj = 0;
12697 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12698 double arg2 ;
12699 void *argp1 = 0 ;
12700 int res1 = 0 ;
12701 double val2 ;
12702 int ecode2 = 0 ;
12703 PyObject *swig_obj[2] ;
12704
12705 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
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_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12709 }
12710 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12711 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12712 if (!SWIG_IsOK(ecode2)) {
12713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12714 }
12715 arg2 = static_cast< double >(val2);
12716 if (arg1) (arg1)->value = arg2;
12717
12718 resultobj = SWIG_Py_Void();
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12726 PyObject *resultobj = 0;
12727 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12728 double result;
12729 void *argp1 = 0 ;
12730 int res1 = 0 ;
12731 PyObject *swig_obj[1] ;
12732
12733 if (!args) SWIG_fail;
12734 swig_obj[0] = args;
12735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12736 if (!SWIG_IsOK(res1)) {
12737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12738 }
12739 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12740 result = (double) ((arg1)->value);
12741 resultobj = SWIG_From_double(static_cast< double >(result));
12742 return resultobj;
12743 fail:
12744 return NULL;
12745 }
12746
12747
12748 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12749 PyObject *obj;
12750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12751 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12752 return SWIG_Py_Void();
12753 }
12754
12755 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12756 return SWIG_Python_InitShadowInstance(args);
12757 }
12758
12759 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj = 0;
12761 wxString *arg1 = 0 ;
12762 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12763 int arg3 = (int) -1 ;
12764 wxImage *result = 0 ;
12765 bool temp1 = false ;
12766 long val2 ;
12767 int ecode2 = 0 ;
12768 int val3 ;
12769 int ecode3 = 0 ;
12770 PyObject * obj0 = 0 ;
12771 PyObject * obj1 = 0 ;
12772 PyObject * obj2 = 0 ;
12773 char * kwnames[] = {
12774 (char *) "name",(char *) "type",(char *) "index", NULL
12775 };
12776
12777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12778 {
12779 arg1 = wxString_in_helper(obj0);
12780 if (arg1 == NULL) SWIG_fail;
12781 temp1 = true;
12782 }
12783 if (obj1) {
12784 ecode2 = SWIG_AsVal_long(obj1, &val2);
12785 if (!SWIG_IsOK(ecode2)) {
12786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12787 }
12788 arg2 = static_cast< long >(val2);
12789 }
12790 if (obj2) {
12791 ecode3 = SWIG_AsVal_int(obj2, &val3);
12792 if (!SWIG_IsOK(ecode3)) {
12793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12794 }
12795 arg3 = static_cast< int >(val3);
12796 }
12797 {
12798 PyThreadState* __tstate = wxPyBeginAllowThreads();
12799 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12804 {
12805 if (temp1)
12806 delete arg1;
12807 }
12808 return resultobj;
12809 fail:
12810 {
12811 if (temp1)
12812 delete arg1;
12813 }
12814 return NULL;
12815 }
12816
12817
12818 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12819 PyObject *resultobj = 0;
12820 wxImage *arg1 = (wxImage *) 0 ;
12821 void *argp1 = 0 ;
12822 int res1 = 0 ;
12823 PyObject *swig_obj[1] ;
12824
12825 if (!args) SWIG_fail;
12826 swig_obj[0] = args;
12827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12830 }
12831 arg1 = reinterpret_cast< wxImage * >(argp1);
12832 {
12833 PyThreadState* __tstate = wxPyBeginAllowThreads();
12834 delete arg1;
12835
12836 wxPyEndAllowThreads(__tstate);
12837 if (PyErr_Occurred()) SWIG_fail;
12838 }
12839 resultobj = SWIG_Py_Void();
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12847 PyObject *resultobj = 0;
12848 wxString *arg1 = 0 ;
12849 wxString *arg2 = 0 ;
12850 int arg3 = (int) -1 ;
12851 wxImage *result = 0 ;
12852 bool temp1 = false ;
12853 bool temp2 = false ;
12854 int val3 ;
12855 int ecode3 = 0 ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 PyObject * obj2 = 0 ;
12859 char * kwnames[] = {
12860 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12861 };
12862
12863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12864 {
12865 arg1 = wxString_in_helper(obj0);
12866 if (arg1 == NULL) SWIG_fail;
12867 temp1 = true;
12868 }
12869 {
12870 arg2 = wxString_in_helper(obj1);
12871 if (arg2 == NULL) SWIG_fail;
12872 temp2 = true;
12873 }
12874 if (obj2) {
12875 ecode3 = SWIG_AsVal_int(obj2, &val3);
12876 if (!SWIG_IsOK(ecode3)) {
12877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12878 }
12879 arg3 = static_cast< int >(val3);
12880 }
12881 {
12882 PyThreadState* __tstate = wxPyBeginAllowThreads();
12883 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12888 {
12889 if (temp1)
12890 delete arg1;
12891 }
12892 {
12893 if (temp2)
12894 delete arg2;
12895 }
12896 return resultobj;
12897 fail:
12898 {
12899 if (temp1)
12900 delete arg1;
12901 }
12902 {
12903 if (temp2)
12904 delete arg2;
12905 }
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj = 0;
12912 wxInputStream *arg1 = 0 ;
12913 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12914 int arg3 = (int) -1 ;
12915 wxImage *result = 0 ;
12916 wxPyInputStream *temp1 ;
12917 bool created1 ;
12918 long val2 ;
12919 int ecode2 = 0 ;
12920 int val3 ;
12921 int ecode3 = 0 ;
12922 PyObject * obj0 = 0 ;
12923 PyObject * obj1 = 0 ;
12924 PyObject * obj2 = 0 ;
12925 char * kwnames[] = {
12926 (char *) "stream",(char *) "type",(char *) "index", NULL
12927 };
12928
12929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12930 {
12931 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12932 arg1 = temp1->m_wxis;
12933 created1 = false;
12934 } else {
12935 PyErr_Clear(); // clear the failure of the wxPyConvert above
12936 arg1 = wxPyCBInputStream_create(obj0, false);
12937 if (arg1 == NULL) {
12938 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12939 SWIG_fail;
12940 }
12941 created1 = true;
12942 }
12943 }
12944 if (obj1) {
12945 ecode2 = SWIG_AsVal_long(obj1, &val2);
12946 if (!SWIG_IsOK(ecode2)) {
12947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12948 }
12949 arg2 = static_cast< long >(val2);
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_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12955 }
12956 arg3 = static_cast< int >(val3);
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (wxImage *)new wxImage(*arg1,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 (created1) delete arg1;
12967 }
12968 return resultobj;
12969 fail:
12970 {
12971 if (created1) delete arg1;
12972 }
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12978 PyObject *resultobj = 0;
12979 wxInputStream *arg1 = 0 ;
12980 wxString *arg2 = 0 ;
12981 int arg3 = (int) -1 ;
12982 wxImage *result = 0 ;
12983 wxPyInputStream *temp1 ;
12984 bool created1 ;
12985 bool temp2 = false ;
12986 int val3 ;
12987 int ecode3 = 0 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 PyObject * obj2 = 0 ;
12991 char * kwnames[] = {
12992 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
12993 };
12994
12995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12996 {
12997 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12998 arg1 = temp1->m_wxis;
12999 created1 = false;
13000 } else {
13001 PyErr_Clear(); // clear the failure of the wxPyConvert above
13002 arg1 = wxPyCBInputStream_create(obj0, false);
13003 if (arg1 == NULL) {
13004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13005 SWIG_fail;
13006 }
13007 created1 = true;
13008 }
13009 }
13010 {
13011 arg2 = wxString_in_helper(obj1);
13012 if (arg2 == NULL) SWIG_fail;
13013 temp2 = true;
13014 }
13015 if (obj2) {
13016 ecode3 = SWIG_AsVal_int(obj2, &val3);
13017 if (!SWIG_IsOK(ecode3)) {
13018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13019 }
13020 arg3 = static_cast< int >(val3);
13021 }
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13029 {
13030 if (created1) delete arg1;
13031 }
13032 {
13033 if (temp2)
13034 delete arg2;
13035 }
13036 return resultobj;
13037 fail:
13038 {
13039 if (created1) delete arg1;
13040 }
13041 {
13042 if (temp2)
13043 delete arg2;
13044 }
13045 return NULL;
13046 }
13047
13048
13049 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj = 0;
13051 int arg1 = (int) 0 ;
13052 int arg2 = (int) 0 ;
13053 bool arg3 = (bool) true ;
13054 wxImage *result = 0 ;
13055 int val1 ;
13056 int ecode1 = 0 ;
13057 int val2 ;
13058 int ecode2 = 0 ;
13059 bool val3 ;
13060 int ecode3 = 0 ;
13061 PyObject * obj0 = 0 ;
13062 PyObject * obj1 = 0 ;
13063 PyObject * obj2 = 0 ;
13064 char * kwnames[] = {
13065 (char *) "width",(char *) "height",(char *) "clear", NULL
13066 };
13067
13068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13069 if (obj0) {
13070 ecode1 = SWIG_AsVal_int(obj0, &val1);
13071 if (!SWIG_IsOK(ecode1)) {
13072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13073 }
13074 arg1 = static_cast< int >(val1);
13075 }
13076 if (obj1) {
13077 ecode2 = SWIG_AsVal_int(obj1, &val2);
13078 if (!SWIG_IsOK(ecode2)) {
13079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13080 }
13081 arg2 = static_cast< int >(val2);
13082 }
13083 if (obj2) {
13084 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13085 if (!SWIG_IsOK(ecode3)) {
13086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13087 }
13088 arg3 = static_cast< bool >(val3);
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13097 return resultobj;
13098 fail:
13099 return NULL;
13100 }
13101
13102
13103 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj = 0;
13105 wxBitmap *arg1 = 0 ;
13106 wxImage *result = 0 ;
13107 void *argp1 = 0 ;
13108 int res1 = 0 ;
13109 PyObject * obj0 = 0 ;
13110 char * kwnames[] = {
13111 (char *) "bitmap", NULL
13112 };
13113
13114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13115 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13116 if (!SWIG_IsOK(res1)) {
13117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13118 }
13119 if (!argp1) {
13120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13121 }
13122 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13123 {
13124 if (!wxPyCheckForApp()) SWIG_fail;
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj = 0;
13139 int arg1 ;
13140 int arg2 ;
13141 buffer arg3 ;
13142 int arg4 ;
13143 wxImage *result = 0 ;
13144 int val1 ;
13145 int ecode1 = 0 ;
13146 int val2 ;
13147 int ecode2 = 0 ;
13148 PyObject * obj0 = 0 ;
13149 PyObject * obj1 = 0 ;
13150 PyObject * obj2 = 0 ;
13151 char * kwnames[] = {
13152 (char *) "width",(char *) "height",(char *) "data", NULL
13153 };
13154
13155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13156 ecode1 = SWIG_AsVal_int(obj0, &val1);
13157 if (!SWIG_IsOK(ecode1)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13159 }
13160 arg1 = static_cast< int >(val1);
13161 ecode2 = SWIG_AsVal_int(obj1, &val2);
13162 if (!SWIG_IsOK(ecode2)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13164 }
13165 arg2 = static_cast< int >(val2);
13166 {
13167 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13168 }
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = 0;
13184 int arg1 ;
13185 int arg2 ;
13186 buffer arg3 ;
13187 int arg4 ;
13188 buffer arg5 ;
13189 int arg6 ;
13190 wxImage *result = 0 ;
13191 int val1 ;
13192 int ecode1 = 0 ;
13193 int val2 ;
13194 int ecode2 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 PyObject * obj2 = 0 ;
13198 PyObject * obj3 = 0 ;
13199 char * kwnames[] = {
13200 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13201 };
13202
13203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13204 ecode1 = SWIG_AsVal_int(obj0, &val1);
13205 if (!SWIG_IsOK(ecode1)) {
13206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13207 }
13208 arg1 = static_cast< int >(val1);
13209 ecode2 = SWIG_AsVal_int(obj1, &val2);
13210 if (!SWIG_IsOK(ecode2)) {
13211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13212 }
13213 arg2 = static_cast< int >(val2);
13214 {
13215 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13216 }
13217 {
13218 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13219 }
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 wxImage *arg1 = (wxImage *) 0 ;
13236 int arg2 ;
13237 int arg3 ;
13238 bool arg4 = (bool) true ;
13239 void *argp1 = 0 ;
13240 int res1 = 0 ;
13241 int val2 ;
13242 int ecode2 = 0 ;
13243 int val3 ;
13244 int ecode3 = 0 ;
13245 bool val4 ;
13246 int ecode4 = 0 ;
13247 PyObject * obj0 = 0 ;
13248 PyObject * obj1 = 0 ;
13249 PyObject * obj2 = 0 ;
13250 PyObject * obj3 = 0 ;
13251 char * kwnames[] = {
13252 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13253 };
13254
13255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13257 if (!SWIG_IsOK(res1)) {
13258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13259 }
13260 arg1 = reinterpret_cast< wxImage * >(argp1);
13261 ecode2 = SWIG_AsVal_int(obj1, &val2);
13262 if (!SWIG_IsOK(ecode2)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13264 }
13265 arg2 = static_cast< int >(val2);
13266 ecode3 = SWIG_AsVal_int(obj2, &val3);
13267 if (!SWIG_IsOK(ecode3)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13269 }
13270 arg3 = static_cast< int >(val3);
13271 if (obj3) {
13272 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13273 if (!SWIG_IsOK(ecode4)) {
13274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13275 }
13276 arg4 = static_cast< bool >(val4);
13277 }
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 (arg1)->Create(arg2,arg3,arg4);
13281 wxPyEndAllowThreads(__tstate);
13282 if (PyErr_Occurred()) SWIG_fail;
13283 }
13284 resultobj = SWIG_Py_Void();
13285 return resultobj;
13286 fail:
13287 return NULL;
13288 }
13289
13290
13291 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13292 PyObject *resultobj = 0;
13293 wxImage *arg1 = (wxImage *) 0 ;
13294 void *argp1 = 0 ;
13295 int res1 = 0 ;
13296 PyObject *swig_obj[1] ;
13297
13298 if (!args) SWIG_fail;
13299 swig_obj[0] = args;
13300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13301 if (!SWIG_IsOK(res1)) {
13302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13303 }
13304 arg1 = reinterpret_cast< wxImage * >(argp1);
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 (arg1)->Destroy();
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 resultobj = SWIG_Py_Void();
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj = 0;
13320 wxImage *arg1 = (wxImage *) 0 ;
13321 int arg2 ;
13322 int arg3 ;
13323 SwigValueWrapper<wxImage > result;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 int val2 ;
13327 int ecode2 = 0 ;
13328 int val3 ;
13329 int ecode3 = 0 ;
13330 PyObject * obj0 = 0 ;
13331 PyObject * obj1 = 0 ;
13332 PyObject * obj2 = 0 ;
13333 char * kwnames[] = {
13334 (char *) "self",(char *) "width",(char *) "height", NULL
13335 };
13336
13337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13339 if (!SWIG_IsOK(res1)) {
13340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13341 }
13342 arg1 = reinterpret_cast< wxImage * >(argp1);
13343 ecode2 = SWIG_AsVal_int(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13346 }
13347 arg2 = static_cast< int >(val2);
13348 ecode3 = SWIG_AsVal_int(obj2, &val3);
13349 if (!SWIG_IsOK(ecode3)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13351 }
13352 arg3 = static_cast< int >(val3);
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 result = (arg1)->Scale(arg2,arg3);
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj = 0;
13368 wxImage *arg1 = (wxImage *) 0 ;
13369 int arg2 ;
13370 int arg3 ;
13371 SwigValueWrapper<wxImage > result;
13372 void *argp1 = 0 ;
13373 int res1 = 0 ;
13374 int val2 ;
13375 int ecode2 = 0 ;
13376 int val3 ;
13377 int ecode3 = 0 ;
13378 PyObject * obj0 = 0 ;
13379 PyObject * obj1 = 0 ;
13380 PyObject * obj2 = 0 ;
13381 char * kwnames[] = {
13382 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13383 };
13384
13385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13387 if (!SWIG_IsOK(res1)) {
13388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13389 }
13390 arg1 = reinterpret_cast< wxImage * >(argp1);
13391 ecode2 = SWIG_AsVal_int(obj1, &val2);
13392 if (!SWIG_IsOK(ecode2)) {
13393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13394 }
13395 arg2 = static_cast< int >(val2);
13396 ecode3 = SWIG_AsVal_int(obj2, &val3);
13397 if (!SWIG_IsOK(ecode3)) {
13398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13399 }
13400 arg3 = static_cast< int >(val3);
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj = 0;
13416 wxImage *arg1 = (wxImage *) 0 ;
13417 int arg2 ;
13418 int arg3 ;
13419 wxImage *result = 0 ;
13420 void *argp1 = 0 ;
13421 int res1 = 0 ;
13422 int val2 ;
13423 int ecode2 = 0 ;
13424 int val3 ;
13425 int ecode3 = 0 ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 PyObject * obj2 = 0 ;
13429 char * kwnames[] = {
13430 (char *) "self",(char *) "width",(char *) "height", NULL
13431 };
13432
13433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13435 if (!SWIG_IsOK(res1)) {
13436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13437 }
13438 arg1 = reinterpret_cast< wxImage * >(argp1);
13439 ecode2 = SWIG_AsVal_int(obj1, &val2);
13440 if (!SWIG_IsOK(ecode2)) {
13441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13442 }
13443 arg2 = static_cast< int >(val2);
13444 ecode3 = SWIG_AsVal_int(obj2, &val3);
13445 if (!SWIG_IsOK(ecode3)) {
13446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13447 }
13448 arg3 = static_cast< int >(val3);
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 {
13452 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13453 result = (wxImage *) &_result_ref;
13454 }
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13466 PyObject *resultobj = 0;
13467 wxImage *arg1 = (wxImage *) 0 ;
13468 wxSize *arg2 = 0 ;
13469 wxPoint *arg3 = 0 ;
13470 int arg4 = (int) -1 ;
13471 int arg5 = (int) -1 ;
13472 int arg6 = (int) -1 ;
13473 wxImage *result = 0 ;
13474 void *argp1 = 0 ;
13475 int res1 = 0 ;
13476 wxSize temp2 ;
13477 wxPoint temp3 ;
13478 int val4 ;
13479 int ecode4 = 0 ;
13480 int val5 ;
13481 int ecode5 = 0 ;
13482 int val6 ;
13483 int ecode6 = 0 ;
13484 PyObject * obj0 = 0 ;
13485 PyObject * obj1 = 0 ;
13486 PyObject * obj2 = 0 ;
13487 PyObject * obj3 = 0 ;
13488 PyObject * obj4 = 0 ;
13489 PyObject * obj5 = 0 ;
13490 char * kwnames[] = {
13491 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13492 };
13493
13494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13496 if (!SWIG_IsOK(res1)) {
13497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13498 }
13499 arg1 = reinterpret_cast< wxImage * >(argp1);
13500 {
13501 arg2 = &temp2;
13502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13503 }
13504 {
13505 arg3 = &temp3;
13506 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13507 }
13508 if (obj3) {
13509 ecode4 = SWIG_AsVal_int(obj3, &val4);
13510 if (!SWIG_IsOK(ecode4)) {
13511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13512 }
13513 arg4 = static_cast< int >(val4);
13514 }
13515 if (obj4) {
13516 ecode5 = SWIG_AsVal_int(obj4, &val5);
13517 if (!SWIG_IsOK(ecode5)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13519 }
13520 arg5 = static_cast< int >(val5);
13521 }
13522 if (obj5) {
13523 ecode6 = SWIG_AsVal_int(obj5, &val6);
13524 if (!SWIG_IsOK(ecode6)) {
13525 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13526 }
13527 arg6 = static_cast< int >(val6);
13528 }
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 {
13532 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13533 result = (wxImage *) &_result_ref;
13534 }
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = 0;
13547 wxImage *arg1 = (wxImage *) 0 ;
13548 int arg2 ;
13549 int arg3 ;
13550 byte arg4 ;
13551 byte arg5 ;
13552 byte arg6 ;
13553 void *argp1 = 0 ;
13554 int res1 = 0 ;
13555 int val2 ;
13556 int ecode2 = 0 ;
13557 int val3 ;
13558 int ecode3 = 0 ;
13559 unsigned char val4 ;
13560 int ecode4 = 0 ;
13561 unsigned char val5 ;
13562 int ecode5 = 0 ;
13563 unsigned char val6 ;
13564 int ecode6 = 0 ;
13565 PyObject * obj0 = 0 ;
13566 PyObject * obj1 = 0 ;
13567 PyObject * obj2 = 0 ;
13568 PyObject * obj3 = 0 ;
13569 PyObject * obj4 = 0 ;
13570 PyObject * obj5 = 0 ;
13571 char * kwnames[] = {
13572 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13573 };
13574
13575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13577 if (!SWIG_IsOK(res1)) {
13578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13579 }
13580 arg1 = reinterpret_cast< wxImage * >(argp1);
13581 ecode2 = SWIG_AsVal_int(obj1, &val2);
13582 if (!SWIG_IsOK(ecode2)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13584 }
13585 arg2 = static_cast< int >(val2);
13586 ecode3 = SWIG_AsVal_int(obj2, &val3);
13587 if (!SWIG_IsOK(ecode3)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13589 }
13590 arg3 = static_cast< int >(val3);
13591 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13592 if (!SWIG_IsOK(ecode4)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13594 }
13595 arg4 = static_cast< byte >(val4);
13596 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13597 if (!SWIG_IsOK(ecode5)) {
13598 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13599 }
13600 arg5 = static_cast< byte >(val5);
13601 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13602 if (!SWIG_IsOK(ecode6)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13604 }
13605 arg6 = static_cast< byte >(val6);
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_Py_Void();
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 wxImage *arg1 = (wxImage *) 0 ;
13622 wxRect *arg2 = 0 ;
13623 byte arg3 ;
13624 byte arg4 ;
13625 byte arg5 ;
13626 void *argp1 = 0 ;
13627 int res1 = 0 ;
13628 wxRect temp2 ;
13629 unsigned char val3 ;
13630 int ecode3 = 0 ;
13631 unsigned char val4 ;
13632 int ecode4 = 0 ;
13633 unsigned char val5 ;
13634 int ecode5 = 0 ;
13635 PyObject * obj0 = 0 ;
13636 PyObject * obj1 = 0 ;
13637 PyObject * obj2 = 0 ;
13638 PyObject * obj3 = 0 ;
13639 PyObject * obj4 = 0 ;
13640 char * kwnames[] = {
13641 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13642 };
13643
13644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13646 if (!SWIG_IsOK(res1)) {
13647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13648 }
13649 arg1 = reinterpret_cast< wxImage * >(argp1);
13650 {
13651 arg2 = &temp2;
13652 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13653 }
13654 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13655 if (!SWIG_IsOK(ecode3)) {
13656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13657 }
13658 arg3 = static_cast< byte >(val3);
13659 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13660 if (!SWIG_IsOK(ecode4)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13662 }
13663 arg4 = static_cast< byte >(val4);
13664 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13665 if (!SWIG_IsOK(ecode5)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13667 }
13668 arg5 = static_cast< byte >(val5);
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_Py_Void();
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxImage *arg1 = (wxImage *) 0 ;
13685 int arg2 ;
13686 int arg3 ;
13687 byte result;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 int val3 ;
13693 int ecode3 = 0 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "x",(char *) "y", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 ecode3 = SWIG_AsVal_int(obj2, &val3);
13713 if (!SWIG_IsOK(ecode3)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13715 }
13716 arg3 = static_cast< int >(val3);
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = (byte)(arg1)->GetRed(arg2,arg3);
13720 wxPyEndAllowThreads(__tstate);
13721 if (PyErr_Occurred()) SWIG_fail;
13722 }
13723 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13724 return resultobj;
13725 fail:
13726 return NULL;
13727 }
13728
13729
13730 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13731 PyObject *resultobj = 0;
13732 wxImage *arg1 = (wxImage *) 0 ;
13733 int arg2 ;
13734 int arg3 ;
13735 byte result;
13736 void *argp1 = 0 ;
13737 int res1 = 0 ;
13738 int val2 ;
13739 int ecode2 = 0 ;
13740 int val3 ;
13741 int ecode3 = 0 ;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 PyObject * obj2 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "self",(char *) "x",(char *) "y", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13751 if (!SWIG_IsOK(res1)) {
13752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13753 }
13754 arg1 = reinterpret_cast< wxImage * >(argp1);
13755 ecode2 = SWIG_AsVal_int(obj1, &val2);
13756 if (!SWIG_IsOK(ecode2)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13758 }
13759 arg2 = static_cast< int >(val2);
13760 ecode3 = SWIG_AsVal_int(obj2, &val3);
13761 if (!SWIG_IsOK(ecode3)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13763 }
13764 arg3 = static_cast< int >(val3);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 result = (byte)(arg1)->GetGreen(arg2,arg3);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 wxImage *arg1 = (wxImage *) 0 ;
13781 int arg2 ;
13782 int arg3 ;
13783 byte result;
13784 void *argp1 = 0 ;
13785 int res1 = 0 ;
13786 int val2 ;
13787 int ecode2 = 0 ;
13788 int val3 ;
13789 int ecode3 = 0 ;
13790 PyObject * obj0 = 0 ;
13791 PyObject * obj1 = 0 ;
13792 PyObject * obj2 = 0 ;
13793 char * kwnames[] = {
13794 (char *) "self",(char *) "x",(char *) "y", NULL
13795 };
13796
13797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13799 if (!SWIG_IsOK(res1)) {
13800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13801 }
13802 arg1 = reinterpret_cast< wxImage * >(argp1);
13803 ecode2 = SWIG_AsVal_int(obj1, &val2);
13804 if (!SWIG_IsOK(ecode2)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13806 }
13807 arg2 = static_cast< int >(val2);
13808 ecode3 = SWIG_AsVal_int(obj2, &val3);
13809 if (!SWIG_IsOK(ecode3)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13811 }
13812 arg3 = static_cast< int >(val3);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (byte)(arg1)->GetBlue(arg2,arg3);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 int arg2 ;
13830 int arg3 ;
13831 byte arg4 ;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 int val3 ;
13837 int ecode3 = 0 ;
13838 unsigned char val4 ;
13839 int ecode4 = 0 ;
13840 PyObject * obj0 = 0 ;
13841 PyObject * obj1 = 0 ;
13842 PyObject * obj2 = 0 ;
13843 PyObject * obj3 = 0 ;
13844 char * kwnames[] = {
13845 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13846 };
13847
13848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13850 if (!SWIG_IsOK(res1)) {
13851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13852 }
13853 arg1 = reinterpret_cast< wxImage * >(argp1);
13854 ecode2 = SWIG_AsVal_int(obj1, &val2);
13855 if (!SWIG_IsOK(ecode2)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13857 }
13858 arg2 = static_cast< int >(val2);
13859 ecode3 = SWIG_AsVal_int(obj2, &val3);
13860 if (!SWIG_IsOK(ecode3)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13862 }
13863 arg3 = static_cast< int >(val3);
13864 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13865 if (!SWIG_IsOK(ecode4)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13867 }
13868 arg4 = static_cast< byte >(val4);
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 (arg1)->SetAlpha(arg2,arg3,arg4);
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 resultobj = SWIG_Py_Void();
13876 return resultobj;
13877 fail:
13878 return NULL;
13879 }
13880
13881
13882 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj = 0;
13884 wxImage *arg1 = (wxImage *) 0 ;
13885 int arg2 ;
13886 int arg3 ;
13887 byte result;
13888 void *argp1 = 0 ;
13889 int res1 = 0 ;
13890 int val2 ;
13891 int ecode2 = 0 ;
13892 int val3 ;
13893 int ecode3 = 0 ;
13894 PyObject * obj0 = 0 ;
13895 PyObject * obj1 = 0 ;
13896 PyObject * obj2 = 0 ;
13897 char * kwnames[] = {
13898 (char *) "self",(char *) "x",(char *) "y", NULL
13899 };
13900
13901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13903 if (!SWIG_IsOK(res1)) {
13904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13905 }
13906 arg1 = reinterpret_cast< wxImage * >(argp1);
13907 ecode2 = SWIG_AsVal_int(obj1, &val2);
13908 if (!SWIG_IsOK(ecode2)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13910 }
13911 arg2 = static_cast< int >(val2);
13912 ecode3 = SWIG_AsVal_int(obj2, &val3);
13913 if (!SWIG_IsOK(ecode3)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13915 }
13916 arg3 = static_cast< int >(val3);
13917 {
13918 PyThreadState* __tstate = wxPyBeginAllowThreads();
13919 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13920 wxPyEndAllowThreads(__tstate);
13921 if (PyErr_Occurred()) SWIG_fail;
13922 }
13923 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13931 PyObject *resultobj = 0;
13932 wxImage *arg1 = (wxImage *) 0 ;
13933 bool result;
13934 void *argp1 = 0 ;
13935 int res1 = 0 ;
13936 PyObject *swig_obj[1] ;
13937
13938 if (!args) SWIG_fail;
13939 swig_obj[0] = args;
13940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13941 if (!SWIG_IsOK(res1)) {
13942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13943 }
13944 arg1 = reinterpret_cast< wxImage * >(argp1);
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (bool)(arg1)->HasAlpha();
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 {
13952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13953 }
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13961 PyObject *resultobj = 0;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 void *argp1 = 0 ;
13964 int res1 = 0 ;
13965 PyObject *swig_obj[1] ;
13966
13967 if (!args) SWIG_fail;
13968 swig_obj[0] = args;
13969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13970 if (!SWIG_IsOK(res1)) {
13971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13972 }
13973 arg1 = reinterpret_cast< wxImage * >(argp1);
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 (arg1)->InitAlpha();
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_Py_Void();
13981 return resultobj;
13982 fail:
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13988 PyObject *resultobj = 0;
13989 wxImage *arg1 = (wxImage *) 0 ;
13990 int arg2 ;
13991 int arg3 ;
13992 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
13993 bool result;
13994 void *argp1 = 0 ;
13995 int res1 = 0 ;
13996 int val2 ;
13997 int ecode2 = 0 ;
13998 int val3 ;
13999 int ecode3 = 0 ;
14000 unsigned char val4 ;
14001 int ecode4 = 0 ;
14002 PyObject * obj0 = 0 ;
14003 PyObject * obj1 = 0 ;
14004 PyObject * obj2 = 0 ;
14005 PyObject * obj3 = 0 ;
14006 char * kwnames[] = {
14007 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14008 };
14009
14010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14012 if (!SWIG_IsOK(res1)) {
14013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14014 }
14015 arg1 = reinterpret_cast< wxImage * >(argp1);
14016 ecode2 = SWIG_AsVal_int(obj1, &val2);
14017 if (!SWIG_IsOK(ecode2)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14019 }
14020 arg2 = static_cast< int >(val2);
14021 ecode3 = SWIG_AsVal_int(obj2, &val3);
14022 if (!SWIG_IsOK(ecode3)) {
14023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14024 }
14025 arg3 = static_cast< int >(val3);
14026 if (obj3) {
14027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14028 if (!SWIG_IsOK(ecode4)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14030 }
14031 arg4 = static_cast< byte >(val4);
14032 }
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 {
14040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14041 }
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj = 0;
14050 wxImage *arg1 = (wxImage *) 0 ;
14051 byte *arg2 = (byte *) 0 ;
14052 byte *arg3 = (byte *) 0 ;
14053 byte *arg4 = (byte *) 0 ;
14054 byte arg5 = (byte) 0 ;
14055 byte arg6 = (byte) 0 ;
14056 byte arg7 = (byte) 0 ;
14057 bool result;
14058 void *argp1 = 0 ;
14059 int res1 = 0 ;
14060 byte temp2 ;
14061 int res2 = SWIG_TMPOBJ ;
14062 byte temp3 ;
14063 int res3 = SWIG_TMPOBJ ;
14064 byte temp4 ;
14065 int res4 = SWIG_TMPOBJ ;
14066 unsigned char val5 ;
14067 int ecode5 = 0 ;
14068 unsigned char val6 ;
14069 int ecode6 = 0 ;
14070 unsigned char val7 ;
14071 int ecode7 = 0 ;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 PyObject * obj2 = 0 ;
14075 PyObject * obj3 = 0 ;
14076 char * kwnames[] = {
14077 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14078 };
14079
14080 arg2 = &temp2;
14081 arg3 = &temp3;
14082 arg4 = &temp4;
14083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14085 if (!SWIG_IsOK(res1)) {
14086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14087 }
14088 arg1 = reinterpret_cast< wxImage * >(argp1);
14089 if (obj1) {
14090 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14091 if (!SWIG_IsOK(ecode5)) {
14092 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14093 }
14094 arg5 = static_cast< byte >(val5);
14095 }
14096 if (obj2) {
14097 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14098 if (!SWIG_IsOK(ecode6)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14100 }
14101 arg6 = static_cast< byte >(val6);
14102 }
14103 if (obj3) {
14104 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14105 if (!SWIG_IsOK(ecode7)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14107 }
14108 arg7 = static_cast< byte >(val7);
14109 }
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14118 }
14119 if (SWIG_IsTmpObj(res2)) {
14120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14121 } else {
14122 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14124 }
14125 if (SWIG_IsTmpObj(res3)) {
14126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14127 } else {
14128 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14130 }
14131 if (SWIG_IsTmpObj(res4)) {
14132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14133 } else {
14134 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14136 }
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj = 0;
14145 wxImage *arg1 = (wxImage *) 0 ;
14146 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14147 bool result;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 unsigned char val2 ;
14151 int ecode2 = 0 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 char * kwnames[] = {
14155 (char *) "self",(char *) "threshold", NULL
14156 };
14157
14158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14160 if (!SWIG_IsOK(res1)) {
14161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14162 }
14163 arg1 = reinterpret_cast< wxImage * >(argp1);
14164 if (obj1) {
14165 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14166 if (!SWIG_IsOK(ecode2)) {
14167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14168 }
14169 arg2 = static_cast< byte >(val2);
14170 }
14171 {
14172 PyThreadState* __tstate = wxPyBeginAllowThreads();
14173 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 {
14178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14179 }
14180 return resultobj;
14181 fail:
14182 return NULL;
14183 }
14184
14185
14186 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14187 PyObject *resultobj = 0;
14188 wxImage *arg1 = (wxImage *) 0 ;
14189 byte arg2 ;
14190 byte arg3 ;
14191 byte arg4 ;
14192 bool result;
14193 void *argp1 = 0 ;
14194 int res1 = 0 ;
14195 unsigned char val2 ;
14196 int ecode2 = 0 ;
14197 unsigned char val3 ;
14198 int ecode3 = 0 ;
14199 unsigned char val4 ;
14200 int ecode4 = 0 ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 PyObject * obj2 = 0 ;
14204 PyObject * obj3 = 0 ;
14205 char * kwnames[] = {
14206 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14207 };
14208
14209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14211 if (!SWIG_IsOK(res1)) {
14212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14213 }
14214 arg1 = reinterpret_cast< wxImage * >(argp1);
14215 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14216 if (!SWIG_IsOK(ecode2)) {
14217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14218 }
14219 arg2 = static_cast< byte >(val2);
14220 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14221 if (!SWIG_IsOK(ecode3)) {
14222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14223 }
14224 arg3 = static_cast< byte >(val3);
14225 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14226 if (!SWIG_IsOK(ecode4)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14228 }
14229 arg4 = static_cast< byte >(val4);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 {
14237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14238 }
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj = 0;
14247 wxImage *arg1 = (wxImage *) 0 ;
14248 wxImage *arg2 = 0 ;
14249 byte arg3 ;
14250 byte arg4 ;
14251 byte arg5 ;
14252 bool result;
14253 void *argp1 = 0 ;
14254 int res1 = 0 ;
14255 void *argp2 = 0 ;
14256 int res2 = 0 ;
14257 unsigned char val3 ;
14258 int ecode3 = 0 ;
14259 unsigned char val4 ;
14260 int ecode4 = 0 ;
14261 unsigned char val5 ;
14262 int ecode5 = 0 ;
14263 PyObject * obj0 = 0 ;
14264 PyObject * obj1 = 0 ;
14265 PyObject * obj2 = 0 ;
14266 PyObject * obj3 = 0 ;
14267 PyObject * obj4 = 0 ;
14268 char * kwnames[] = {
14269 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14270 };
14271
14272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14274 if (!SWIG_IsOK(res1)) {
14275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14276 }
14277 arg1 = reinterpret_cast< wxImage * >(argp1);
14278 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14279 if (!SWIG_IsOK(res2)) {
14280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14281 }
14282 if (!argp2) {
14283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14284 }
14285 arg2 = reinterpret_cast< wxImage * >(argp2);
14286 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14287 if (!SWIG_IsOK(ecode3)) {
14288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14289 }
14290 arg3 = static_cast< byte >(val3);
14291 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14292 if (!SWIG_IsOK(ecode4)) {
14293 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14294 }
14295 arg4 = static_cast< byte >(val4);
14296 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14297 if (!SWIG_IsOK(ecode5)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14299 }
14300 arg5 = static_cast< byte >(val5);
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 {
14308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14309 }
14310 return resultobj;
14311 fail:
14312 return NULL;
14313 }
14314
14315
14316 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj = 0;
14318 wxString *arg1 = 0 ;
14319 bool result;
14320 bool temp1 = false ;
14321 PyObject * obj0 = 0 ;
14322 char * kwnames[] = {
14323 (char *) "filename", NULL
14324 };
14325
14326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14327 {
14328 arg1 = wxString_in_helper(obj0);
14329 if (arg1 == NULL) SWIG_fail;
14330 temp1 = true;
14331 }
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14335 wxPyEndAllowThreads(__tstate);
14336 if (PyErr_Occurred()) SWIG_fail;
14337 }
14338 {
14339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14340 }
14341 {
14342 if (temp1)
14343 delete arg1;
14344 }
14345 return resultobj;
14346 fail:
14347 {
14348 if (temp1)
14349 delete arg1;
14350 }
14351 return NULL;
14352 }
14353
14354
14355 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj = 0;
14357 wxString *arg1 = 0 ;
14358 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14359 int result;
14360 bool temp1 = false ;
14361 long val2 ;
14362 int ecode2 = 0 ;
14363 PyObject * obj0 = 0 ;
14364 PyObject * obj1 = 0 ;
14365 char * kwnames[] = {
14366 (char *) "filename",(char *) "type", NULL
14367 };
14368
14369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14370 {
14371 arg1 = wxString_in_helper(obj0);
14372 if (arg1 == NULL) SWIG_fail;
14373 temp1 = true;
14374 }
14375 if (obj1) {
14376 ecode2 = SWIG_AsVal_long(obj1, &val2);
14377 if (!SWIG_IsOK(ecode2)) {
14378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14379 }
14380 arg2 = static_cast< long >(val2);
14381 }
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 resultobj = SWIG_From_int(static_cast< int >(result));
14389 {
14390 if (temp1)
14391 delete arg1;
14392 }
14393 return resultobj;
14394 fail:
14395 {
14396 if (temp1)
14397 delete arg1;
14398 }
14399 return NULL;
14400 }
14401
14402
14403 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14404 PyObject *resultobj = 0;
14405 wxImage *arg1 = (wxImage *) 0 ;
14406 wxString *arg2 = 0 ;
14407 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14408 int arg4 = (int) -1 ;
14409 bool result;
14410 void *argp1 = 0 ;
14411 int res1 = 0 ;
14412 bool temp2 = false ;
14413 long val3 ;
14414 int ecode3 = 0 ;
14415 int val4 ;
14416 int ecode4 = 0 ;
14417 PyObject * obj0 = 0 ;
14418 PyObject * obj1 = 0 ;
14419 PyObject * obj2 = 0 ;
14420 PyObject * obj3 = 0 ;
14421 char * kwnames[] = {
14422 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14423 };
14424
14425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14427 if (!SWIG_IsOK(res1)) {
14428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14429 }
14430 arg1 = reinterpret_cast< wxImage * >(argp1);
14431 {
14432 arg2 = wxString_in_helper(obj1);
14433 if (arg2 == NULL) SWIG_fail;
14434 temp2 = true;
14435 }
14436 if (obj2) {
14437 ecode3 = SWIG_AsVal_long(obj2, &val3);
14438 if (!SWIG_IsOK(ecode3)) {
14439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14440 }
14441 arg3 = static_cast< long >(val3);
14442 }
14443 if (obj3) {
14444 ecode4 = SWIG_AsVal_int(obj3, &val4);
14445 if (!SWIG_IsOK(ecode4)) {
14446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14447 }
14448 arg4 = static_cast< int >(val4);
14449 }
14450 {
14451 PyThreadState* __tstate = wxPyBeginAllowThreads();
14452 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 {
14457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14458 }
14459 {
14460 if (temp2)
14461 delete arg2;
14462 }
14463 return resultobj;
14464 fail:
14465 {
14466 if (temp2)
14467 delete arg2;
14468 }
14469 return NULL;
14470 }
14471
14472
14473 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14474 PyObject *resultobj = 0;
14475 wxImage *arg1 = (wxImage *) 0 ;
14476 wxString *arg2 = 0 ;
14477 wxString *arg3 = 0 ;
14478 int arg4 = (int) -1 ;
14479 bool result;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 bool temp2 = false ;
14483 bool temp3 = false ;
14484 int val4 ;
14485 int ecode4 = 0 ;
14486 PyObject * obj0 = 0 ;
14487 PyObject * obj1 = 0 ;
14488 PyObject * obj2 = 0 ;
14489 PyObject * obj3 = 0 ;
14490 char * kwnames[] = {
14491 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14492 };
14493
14494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14496 if (!SWIG_IsOK(res1)) {
14497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14498 }
14499 arg1 = reinterpret_cast< wxImage * >(argp1);
14500 {
14501 arg2 = wxString_in_helper(obj1);
14502 if (arg2 == NULL) SWIG_fail;
14503 temp2 = true;
14504 }
14505 {
14506 arg3 = wxString_in_helper(obj2);
14507 if (arg3 == NULL) SWIG_fail;
14508 temp3 = true;
14509 }
14510 if (obj3) {
14511 ecode4 = SWIG_AsVal_int(obj3, &val4);
14512 if (!SWIG_IsOK(ecode4)) {
14513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14514 }
14515 arg4 = static_cast< int >(val4);
14516 }
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 {
14524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14525 }
14526 {
14527 if (temp2)
14528 delete arg2;
14529 }
14530 {
14531 if (temp3)
14532 delete arg3;
14533 }
14534 return resultobj;
14535 fail:
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 {
14541 if (temp3)
14542 delete arg3;
14543 }
14544 return NULL;
14545 }
14546
14547
14548 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj = 0;
14550 wxImage *arg1 = (wxImage *) 0 ;
14551 wxString *arg2 = 0 ;
14552 int arg3 ;
14553 bool result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 bool temp2 = false ;
14557 int val3 ;
14558 int ecode3 = 0 ;
14559 PyObject * obj0 = 0 ;
14560 PyObject * obj1 = 0 ;
14561 PyObject * obj2 = 0 ;
14562 char * kwnames[] = {
14563 (char *) "self",(char *) "name",(char *) "type", NULL
14564 };
14565
14566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14568 if (!SWIG_IsOK(res1)) {
14569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14570 }
14571 arg1 = reinterpret_cast< wxImage * >(argp1);
14572 {
14573 arg2 = wxString_in_helper(obj1);
14574 if (arg2 == NULL) SWIG_fail;
14575 temp2 = true;
14576 }
14577 ecode3 = SWIG_AsVal_int(obj2, &val3);
14578 if (!SWIG_IsOK(ecode3)) {
14579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14580 }
14581 arg3 = static_cast< int >(val3);
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 {
14589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14590 }
14591 {
14592 if (temp2)
14593 delete arg2;
14594 }
14595 return resultobj;
14596 fail:
14597 {
14598 if (temp2)
14599 delete arg2;
14600 }
14601 return NULL;
14602 }
14603
14604
14605 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14606 PyObject *resultobj = 0;
14607 wxImage *arg1 = (wxImage *) 0 ;
14608 wxString *arg2 = 0 ;
14609 wxString *arg3 = 0 ;
14610 bool result;
14611 void *argp1 = 0 ;
14612 int res1 = 0 ;
14613 bool temp2 = false ;
14614 bool temp3 = false ;
14615 PyObject * obj0 = 0 ;
14616 PyObject * obj1 = 0 ;
14617 PyObject * obj2 = 0 ;
14618 char * kwnames[] = {
14619 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14620 };
14621
14622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14624 if (!SWIG_IsOK(res1)) {
14625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14626 }
14627 arg1 = reinterpret_cast< wxImage * >(argp1);
14628 {
14629 arg2 = wxString_in_helper(obj1);
14630 if (arg2 == NULL) SWIG_fail;
14631 temp2 = true;
14632 }
14633 {
14634 arg3 = wxString_in_helper(obj2);
14635 if (arg3 == NULL) SWIG_fail;
14636 temp3 = true;
14637 }
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 {
14645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14646 }
14647 {
14648 if (temp2)
14649 delete arg2;
14650 }
14651 {
14652 if (temp3)
14653 delete arg3;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 {
14662 if (temp3)
14663 delete arg3;
14664 }
14665 return NULL;
14666 }
14667
14668
14669 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14670 PyObject *resultobj = 0;
14671 wxInputStream *arg1 = 0 ;
14672 bool result;
14673 wxPyInputStream *temp1 ;
14674 bool created1 ;
14675 PyObject * obj0 = 0 ;
14676 char * kwnames[] = {
14677 (char *) "stream", NULL
14678 };
14679
14680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14681 {
14682 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14683 arg1 = temp1->m_wxis;
14684 created1 = false;
14685 } else {
14686 PyErr_Clear(); // clear the failure of the wxPyConvert above
14687 arg1 = wxPyCBInputStream_create(obj0, false);
14688 if (arg1 == NULL) {
14689 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14690 SWIG_fail;
14691 }
14692 created1 = true;
14693 }
14694 }
14695 {
14696 PyThreadState* __tstate = wxPyBeginAllowThreads();
14697 result = (bool)wxImage::CanRead(*arg1);
14698 wxPyEndAllowThreads(__tstate);
14699 if (PyErr_Occurred()) SWIG_fail;
14700 }
14701 {
14702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14703 }
14704 {
14705 if (created1) delete arg1;
14706 }
14707 return resultobj;
14708 fail:
14709 {
14710 if (created1) delete arg1;
14711 }
14712 return NULL;
14713 }
14714
14715
14716 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14717 PyObject *resultobj = 0;
14718 wxImage *arg1 = (wxImage *) 0 ;
14719 wxInputStream *arg2 = 0 ;
14720 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14721 int arg4 = (int) -1 ;
14722 bool result;
14723 void *argp1 = 0 ;
14724 int res1 = 0 ;
14725 wxPyInputStream *temp2 ;
14726 bool created2 ;
14727 long val3 ;
14728 int ecode3 = 0 ;
14729 int val4 ;
14730 int ecode4 = 0 ;
14731 PyObject * obj0 = 0 ;
14732 PyObject * obj1 = 0 ;
14733 PyObject * obj2 = 0 ;
14734 PyObject * obj3 = 0 ;
14735 char * kwnames[] = {
14736 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14737 };
14738
14739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14741 if (!SWIG_IsOK(res1)) {
14742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14743 }
14744 arg1 = reinterpret_cast< wxImage * >(argp1);
14745 {
14746 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14747 arg2 = temp2->m_wxis;
14748 created2 = false;
14749 } else {
14750 PyErr_Clear(); // clear the failure of the wxPyConvert above
14751 arg2 = wxPyCBInputStream_create(obj1, false);
14752 if (arg2 == NULL) {
14753 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14754 SWIG_fail;
14755 }
14756 created2 = true;
14757 }
14758 }
14759 if (obj2) {
14760 ecode3 = SWIG_AsVal_long(obj2, &val3);
14761 if (!SWIG_IsOK(ecode3)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14763 }
14764 arg3 = static_cast< long >(val3);
14765 }
14766 if (obj3) {
14767 ecode4 = SWIG_AsVal_int(obj3, &val4);
14768 if (!SWIG_IsOK(ecode4)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14770 }
14771 arg4 = static_cast< int >(val4);
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (created2) delete arg2;
14784 }
14785 return resultobj;
14786 fail:
14787 {
14788 if (created2) delete arg2;
14789 }
14790 return NULL;
14791 }
14792
14793
14794 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj = 0;
14796 wxImage *arg1 = (wxImage *) 0 ;
14797 wxInputStream *arg2 = 0 ;
14798 wxString *arg3 = 0 ;
14799 int arg4 = (int) -1 ;
14800 bool result;
14801 void *argp1 = 0 ;
14802 int res1 = 0 ;
14803 wxPyInputStream *temp2 ;
14804 bool created2 ;
14805 bool temp3 = false ;
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 *) "mimetype",(char *) "index", NULL
14814 };
14815
14816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",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_LoadMimeStream" "', 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 {
14837 arg3 = wxString_in_helper(obj2);
14838 if (arg3 == NULL) SWIG_fail;
14839 temp3 = true;
14840 }
14841 if (obj3) {
14842 ecode4 = SWIG_AsVal_int(obj3, &val4);
14843 if (!SWIG_IsOK(ecode4)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14845 }
14846 arg4 = static_cast< int >(val4);
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 {
14855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14856 }
14857 {
14858 if (created2) delete arg2;
14859 }
14860 {
14861 if (temp3)
14862 delete arg3;
14863 }
14864 return resultobj;
14865 fail:
14866 {
14867 if (created2) delete arg2;
14868 }
14869 {
14870 if (temp3)
14871 delete arg3;
14872 }
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14878 PyObject *resultobj = 0;
14879 wxImage *arg1 = (wxImage *) 0 ;
14880 bool result;
14881 void *argp1 = 0 ;
14882 int res1 = 0 ;
14883 PyObject *swig_obj[1] ;
14884
14885 if (!args) SWIG_fail;
14886 swig_obj[0] = args;
14887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14888 if (!SWIG_IsOK(res1)) {
14889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14890 }
14891 arg1 = reinterpret_cast< wxImage * >(argp1);
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = (bool)(arg1)->Ok();
14895 wxPyEndAllowThreads(__tstate);
14896 if (PyErr_Occurred()) SWIG_fail;
14897 }
14898 {
14899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14900 }
14901 return resultobj;
14902 fail:
14903 return NULL;
14904 }
14905
14906
14907 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14908 PyObject *resultobj = 0;
14909 wxImage *arg1 = (wxImage *) 0 ;
14910 int result;
14911 void *argp1 = 0 ;
14912 int res1 = 0 ;
14913 PyObject *swig_obj[1] ;
14914
14915 if (!args) SWIG_fail;
14916 swig_obj[0] = args;
14917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14918 if (!SWIG_IsOK(res1)) {
14919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14920 }
14921 arg1 = reinterpret_cast< wxImage * >(argp1);
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 result = (int)(arg1)->GetWidth();
14925 wxPyEndAllowThreads(__tstate);
14926 if (PyErr_Occurred()) SWIG_fail;
14927 }
14928 resultobj = SWIG_From_int(static_cast< int >(result));
14929 return resultobj;
14930 fail:
14931 return NULL;
14932 }
14933
14934
14935 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14936 PyObject *resultobj = 0;
14937 wxImage *arg1 = (wxImage *) 0 ;
14938 int result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 PyObject *swig_obj[1] ;
14942
14943 if (!args) SWIG_fail;
14944 swig_obj[0] = args;
14945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14946 if (!SWIG_IsOK(res1)) {
14947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14948 }
14949 arg1 = reinterpret_cast< wxImage * >(argp1);
14950 {
14951 PyThreadState* __tstate = wxPyBeginAllowThreads();
14952 result = (int)(arg1)->GetHeight();
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 resultobj = SWIG_From_int(static_cast< int >(result));
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxImage *arg1 = (wxImage *) 0 ;
14966 wxSize result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14976 }
14977 arg1 = reinterpret_cast< wxImage * >(argp1);
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 result = wxImage_GetSize(arg1);
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14985 return resultobj;
14986 fail:
14987 return NULL;
14988 }
14989
14990
14991 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14992 PyObject *resultobj = 0;
14993 wxImage *arg1 = (wxImage *) 0 ;
14994 wxRect *arg2 = 0 ;
14995 SwigValueWrapper<wxImage > result;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 wxRect temp2 ;
14999 PyObject * obj0 = 0 ;
15000 PyObject * obj1 = 0 ;
15001 char * kwnames[] = {
15002 (char *) "self",(char *) "rect", NULL
15003 };
15004
15005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15007 if (!SWIG_IsOK(res1)) {
15008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15009 }
15010 arg1 = reinterpret_cast< wxImage * >(argp1);
15011 {
15012 arg2 = &temp2;
15013 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15014 }
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxImage *arg1 = (wxImage *) 0 ;
15031 wxSize *arg2 = 0 ;
15032 wxPoint *arg3 = 0 ;
15033 int arg4 = (int) -1 ;
15034 int arg5 = (int) -1 ;
15035 int arg6 = (int) -1 ;
15036 SwigValueWrapper<wxImage > result;
15037 void *argp1 = 0 ;
15038 int res1 = 0 ;
15039 wxSize temp2 ;
15040 wxPoint temp3 ;
15041 int val4 ;
15042 int ecode4 = 0 ;
15043 int val5 ;
15044 int ecode5 = 0 ;
15045 int val6 ;
15046 int ecode6 = 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 PyObject * obj2 = 0 ;
15050 PyObject * obj3 = 0 ;
15051 PyObject * obj4 = 0 ;
15052 PyObject * obj5 = 0 ;
15053 char * kwnames[] = {
15054 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15055 };
15056
15057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15059 if (!SWIG_IsOK(res1)) {
15060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15061 }
15062 arg1 = reinterpret_cast< wxImage * >(argp1);
15063 {
15064 arg2 = &temp2;
15065 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15066 }
15067 {
15068 arg3 = &temp3;
15069 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15070 }
15071 if (obj3) {
15072 ecode4 = SWIG_AsVal_int(obj3, &val4);
15073 if (!SWIG_IsOK(ecode4)) {
15074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15075 }
15076 arg4 = static_cast< int >(val4);
15077 }
15078 if (obj4) {
15079 ecode5 = SWIG_AsVal_int(obj4, &val5);
15080 if (!SWIG_IsOK(ecode5)) {
15081 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15082 }
15083 arg5 = static_cast< int >(val5);
15084 }
15085 if (obj5) {
15086 ecode6 = SWIG_AsVal_int(obj5, &val6);
15087 if (!SWIG_IsOK(ecode6)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15089 }
15090 arg6 = static_cast< int >(val6);
15091 }
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
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_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 PyObject *resultobj = 0;
15107 wxImage *arg1 = (wxImage *) 0 ;
15108 SwigValueWrapper<wxImage > result;
15109 void *argp1 = 0 ;
15110 int res1 = 0 ;
15111 PyObject *swig_obj[1] ;
15112
15113 if (!args) SWIG_fail;
15114 swig_obj[0] = args;
15115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15116 if (!SWIG_IsOK(res1)) {
15117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15118 }
15119 arg1 = reinterpret_cast< wxImage * >(argp1);
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (arg1)->Copy();
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj = 0;
15135 wxImage *arg1 = (wxImage *) 0 ;
15136 wxImage *arg2 = 0 ;
15137 int arg3 ;
15138 int arg4 ;
15139 void *argp1 = 0 ;
15140 int res1 = 0 ;
15141 void *argp2 = 0 ;
15142 int res2 = 0 ;
15143 int val3 ;
15144 int ecode3 = 0 ;
15145 int val4 ;
15146 int ecode4 = 0 ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 PyObject * obj2 = 0 ;
15150 PyObject * obj3 = 0 ;
15151 char * kwnames[] = {
15152 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15153 };
15154
15155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15159 }
15160 arg1 = reinterpret_cast< wxImage * >(argp1);
15161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15162 if (!SWIG_IsOK(res2)) {
15163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15164 }
15165 if (!argp2) {
15166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15167 }
15168 arg2 = reinterpret_cast< wxImage * >(argp2);
15169 ecode3 = SWIG_AsVal_int(obj2, &val3);
15170 if (!SWIG_IsOK(ecode3)) {
15171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15172 }
15173 arg3 = static_cast< int >(val3);
15174 ecode4 = SWIG_AsVal_int(obj3, &val4);
15175 if (!SWIG_IsOK(ecode4)) {
15176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15177 }
15178 arg4 = static_cast< int >(val4);
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 resultobj = SWIG_Py_Void();
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *resultobj = 0;
15194 wxImage *arg1 = (wxImage *) 0 ;
15195 PyObject *result = 0 ;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 PyObject *swig_obj[1] ;
15199
15200 if (!args) SWIG_fail;
15201 swig_obj[0] = args;
15202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage * >(argp1);
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (PyObject *)wxImage_GetData(arg1);
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = result;
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 wxImage *arg1 = (wxImage *) 0 ;
15223 buffer arg2 ;
15224 int arg3 ;
15225 void *argp1 = 0 ;
15226 int res1 = 0 ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 char * kwnames[] = {
15230 (char *) "self",(char *) "data", NULL
15231 };
15232
15233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15237 }
15238 arg1 = reinterpret_cast< wxImage * >(argp1);
15239 {
15240 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15241 }
15242 {
15243 PyThreadState* __tstate = wxPyBeginAllowThreads();
15244 wxImage_SetData(arg1,arg2,arg3);
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 resultobj = SWIG_Py_Void();
15249 return resultobj;
15250 fail:
15251 return NULL;
15252 }
15253
15254
15255 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15256 PyObject *resultobj = 0;
15257 wxImage *arg1 = (wxImage *) 0 ;
15258 PyObject *result = 0 ;
15259 void *argp1 = 0 ;
15260 int res1 = 0 ;
15261 PyObject *swig_obj[1] ;
15262
15263 if (!args) SWIG_fail;
15264 swig_obj[0] = args;
15265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15266 if (!SWIG_IsOK(res1)) {
15267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15268 }
15269 arg1 = reinterpret_cast< wxImage * >(argp1);
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15273 wxPyEndAllowThreads(__tstate);
15274 if (PyErr_Occurred()) SWIG_fail;
15275 }
15276 resultobj = result;
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15284 PyObject *resultobj = 0;
15285 wxImage *arg1 = (wxImage *) 0 ;
15286 buffer arg2 ;
15287 int arg3 ;
15288 void *argp1 = 0 ;
15289 int res1 = 0 ;
15290 PyObject * obj0 = 0 ;
15291 PyObject * obj1 = 0 ;
15292 char * kwnames[] = {
15293 (char *) "self",(char *) "data", NULL
15294 };
15295
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15300 }
15301 arg1 = reinterpret_cast< wxImage * >(argp1);
15302 {
15303 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15304 }
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 wxImage_SetDataBuffer(arg1,arg2,arg3);
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 resultobj = SWIG_Py_Void();
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15319 PyObject *resultobj = 0;
15320 wxImage *arg1 = (wxImage *) 0 ;
15321 PyObject *result = 0 ;
15322 void *argp1 = 0 ;
15323 int res1 = 0 ;
15324 PyObject *swig_obj[1] ;
15325
15326 if (!args) SWIG_fail;
15327 swig_obj[0] = args;
15328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15329 if (!SWIG_IsOK(res1)) {
15330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15331 }
15332 arg1 = reinterpret_cast< wxImage * >(argp1);
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (PyObject *)wxImage_GetAlphaData(arg1);
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 resultobj = result;
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15347 PyObject *resultobj = 0;
15348 wxImage *arg1 = (wxImage *) 0 ;
15349 buffer arg2 ;
15350 int arg3 ;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 char * kwnames[] = {
15356 (char *) "self",(char *) "alpha", NULL
15357 };
15358
15359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15363 }
15364 arg1 = reinterpret_cast< wxImage * >(argp1);
15365 {
15366 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15367 }
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 wxImage_SetAlphaData(arg1,arg2,arg3);
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_Py_Void();
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15382 PyObject *resultobj = 0;
15383 wxImage *arg1 = (wxImage *) 0 ;
15384 PyObject *result = 0 ;
15385 void *argp1 = 0 ;
15386 int res1 = 0 ;
15387 PyObject *swig_obj[1] ;
15388
15389 if (!args) SWIG_fail;
15390 swig_obj[0] = args;
15391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15394 }
15395 arg1 = reinterpret_cast< wxImage * >(argp1);
15396 {
15397 PyThreadState* __tstate = wxPyBeginAllowThreads();
15398 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = result;
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj = 0;
15411 wxImage *arg1 = (wxImage *) 0 ;
15412 buffer arg2 ;
15413 int arg3 ;
15414 void *argp1 = 0 ;
15415 int res1 = 0 ;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 char * kwnames[] = {
15419 (char *) "self",(char *) "alpha", NULL
15420 };
15421
15422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15426 }
15427 arg1 = reinterpret_cast< wxImage * >(argp1);
15428 {
15429 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15430 }
15431 {
15432 PyThreadState* __tstate = wxPyBeginAllowThreads();
15433 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 resultobj = SWIG_Py_Void();
15438 return resultobj;
15439 fail:
15440 return NULL;
15441 }
15442
15443
15444 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15445 PyObject *resultobj = 0;
15446 wxImage *arg1 = (wxImage *) 0 ;
15447 byte arg2 ;
15448 byte arg3 ;
15449 byte arg4 ;
15450 void *argp1 = 0 ;
15451 int res1 = 0 ;
15452 unsigned char val2 ;
15453 int ecode2 = 0 ;
15454 unsigned char val3 ;
15455 int ecode3 = 0 ;
15456 unsigned char val4 ;
15457 int ecode4 = 0 ;
15458 PyObject * obj0 = 0 ;
15459 PyObject * obj1 = 0 ;
15460 PyObject * obj2 = 0 ;
15461 PyObject * obj3 = 0 ;
15462 char * kwnames[] = {
15463 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15464 };
15465
15466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15468 if (!SWIG_IsOK(res1)) {
15469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15470 }
15471 arg1 = reinterpret_cast< wxImage * >(argp1);
15472 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15473 if (!SWIG_IsOK(ecode2)) {
15474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15475 }
15476 arg2 = static_cast< byte >(val2);
15477 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15478 if (!SWIG_IsOK(ecode3)) {
15479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15480 }
15481 arg3 = static_cast< byte >(val3);
15482 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15483 if (!SWIG_IsOK(ecode4)) {
15484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15485 }
15486 arg4 = static_cast< byte >(val4);
15487 {
15488 PyThreadState* __tstate = wxPyBeginAllowThreads();
15489 (arg1)->SetMaskColour(arg2,arg3,arg4);
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 resultobj = SWIG_Py_Void();
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15501 PyObject *resultobj = 0;
15502 wxImage *arg1 = (wxImage *) 0 ;
15503 byte *arg2 = (byte *) 0 ;
15504 byte *arg3 = (byte *) 0 ;
15505 byte *arg4 = (byte *) 0 ;
15506 void *argp1 = 0 ;
15507 int res1 = 0 ;
15508 byte temp2 ;
15509 int res2 = SWIG_TMPOBJ ;
15510 byte temp3 ;
15511 int res3 = SWIG_TMPOBJ ;
15512 byte temp4 ;
15513 int res4 = SWIG_TMPOBJ ;
15514 PyObject *swig_obj[1] ;
15515
15516 arg2 = &temp2;
15517 arg3 = &temp3;
15518 arg4 = &temp4;
15519 if (!args) SWIG_fail;
15520 swig_obj[0] = args;
15521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15522 if (!SWIG_IsOK(res1)) {
15523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15524 }
15525 arg1 = reinterpret_cast< wxImage * >(argp1);
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 resultobj = SWIG_Py_Void();
15533 if (SWIG_IsTmpObj(res2)) {
15534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15535 } else {
15536 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15538 }
15539 if (SWIG_IsTmpObj(res3)) {
15540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15541 } else {
15542 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15544 }
15545 if (SWIG_IsTmpObj(res4)) {
15546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15547 } else {
15548 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15550 }
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15558 PyObject *resultobj = 0;
15559 wxImage *arg1 = (wxImage *) 0 ;
15560 byte result;
15561 void *argp1 = 0 ;
15562 int res1 = 0 ;
15563 PyObject *swig_obj[1] ;
15564
15565 if (!args) SWIG_fail;
15566 swig_obj[0] = args;
15567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 PyThreadState* __tstate = wxPyBeginAllowThreads();
15574 result = (byte)(arg1)->GetMaskRed();
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15586 PyObject *resultobj = 0;
15587 wxImage *arg1 = (wxImage *) 0 ;
15588 byte result;
15589 void *argp1 = 0 ;
15590 int res1 = 0 ;
15591 PyObject *swig_obj[1] ;
15592
15593 if (!args) SWIG_fail;
15594 swig_obj[0] = args;
15595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15596 if (!SWIG_IsOK(res1)) {
15597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15598 }
15599 arg1 = reinterpret_cast< wxImage * >(argp1);
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (byte)(arg1)->GetMaskGreen();
15603 wxPyEndAllowThreads(__tstate);
15604 if (PyErr_Occurred()) SWIG_fail;
15605 }
15606 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15607 return resultobj;
15608 fail:
15609 return NULL;
15610 }
15611
15612
15613 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15614 PyObject *resultobj = 0;
15615 wxImage *arg1 = (wxImage *) 0 ;
15616 byte result;
15617 void *argp1 = 0 ;
15618 int res1 = 0 ;
15619 PyObject *swig_obj[1] ;
15620
15621 if (!args) SWIG_fail;
15622 swig_obj[0] = args;
15623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15624 if (!SWIG_IsOK(res1)) {
15625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15626 }
15627 arg1 = reinterpret_cast< wxImage * >(argp1);
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (byte)(arg1)->GetMaskBlue();
15631 wxPyEndAllowThreads(__tstate);
15632 if (PyErr_Occurred()) SWIG_fail;
15633 }
15634 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15635 return resultobj;
15636 fail:
15637 return NULL;
15638 }
15639
15640
15641 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15642 PyObject *resultobj = 0;
15643 wxImage *arg1 = (wxImage *) 0 ;
15644 bool arg2 = (bool) true ;
15645 void *argp1 = 0 ;
15646 int res1 = 0 ;
15647 bool val2 ;
15648 int ecode2 = 0 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 char * kwnames[] = {
15652 (char *) "self",(char *) "mask", NULL
15653 };
15654
15655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15657 if (!SWIG_IsOK(res1)) {
15658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15659 }
15660 arg1 = reinterpret_cast< wxImage * >(argp1);
15661 if (obj1) {
15662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15663 if (!SWIG_IsOK(ecode2)) {
15664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15665 }
15666 arg2 = static_cast< bool >(val2);
15667 }
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 (arg1)->SetMask(arg2);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_Py_Void();
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 bool result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15694 }
15695 arg1 = reinterpret_cast< wxImage * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (bool)(arg1)->HasMask();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 {
15703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15704 }
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj = 0;
15713 wxImage *arg1 = (wxImage *) 0 ;
15714 double arg2 ;
15715 wxPoint *arg3 = 0 ;
15716 bool arg4 = (bool) true ;
15717 wxPoint *arg5 = (wxPoint *) NULL ;
15718 SwigValueWrapper<wxImage > result;
15719 void *argp1 = 0 ;
15720 int res1 = 0 ;
15721 double val2 ;
15722 int ecode2 = 0 ;
15723 wxPoint temp3 ;
15724 bool val4 ;
15725 int ecode4 = 0 ;
15726 void *argp5 = 0 ;
15727 int res5 = 0 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 PyObject * obj2 = 0 ;
15731 PyObject * obj3 = 0 ;
15732 PyObject * obj4 = 0 ;
15733 char * kwnames[] = {
15734 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15735 };
15736
15737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15739 if (!SWIG_IsOK(res1)) {
15740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15741 }
15742 arg1 = reinterpret_cast< wxImage * >(argp1);
15743 ecode2 = SWIG_AsVal_double(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15746 }
15747 arg2 = static_cast< double >(val2);
15748 {
15749 arg3 = &temp3;
15750 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15751 }
15752 if (obj3) {
15753 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15754 if (!SWIG_IsOK(ecode4)) {
15755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15756 }
15757 arg4 = static_cast< bool >(val4);
15758 }
15759 if (obj4) {
15760 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15761 if (!SWIG_IsOK(res5)) {
15762 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15763 }
15764 arg5 = reinterpret_cast< wxPoint * >(argp5);
15765 }
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15769 wxPyEndAllowThreads(__tstate);
15770 if (PyErr_Occurred()) SWIG_fail;
15771 }
15772 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15773 return resultobj;
15774 fail:
15775 return NULL;
15776 }
15777
15778
15779 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15780 PyObject *resultobj = 0;
15781 wxImage *arg1 = (wxImage *) 0 ;
15782 bool arg2 = (bool) true ;
15783 SwigValueWrapper<wxImage > result;
15784 void *argp1 = 0 ;
15785 int res1 = 0 ;
15786 bool val2 ;
15787 int ecode2 = 0 ;
15788 PyObject * obj0 = 0 ;
15789 PyObject * obj1 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "self",(char *) "clockwise", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15796 if (!SWIG_IsOK(res1)) {
15797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15798 }
15799 arg1 = reinterpret_cast< wxImage * >(argp1);
15800 if (obj1) {
15801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15802 if (!SWIG_IsOK(ecode2)) {
15803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15804 }
15805 arg2 = static_cast< bool >(val2);
15806 }
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (arg1)->Rotate90(arg2);
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15821 PyObject *resultobj = 0;
15822 wxImage *arg1 = (wxImage *) 0 ;
15823 bool arg2 = (bool) true ;
15824 SwigValueWrapper<wxImage > result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 bool val2 ;
15828 int ecode2 = 0 ;
15829 PyObject * obj0 = 0 ;
15830 PyObject * obj1 = 0 ;
15831 char * kwnames[] = {
15832 (char *) "self",(char *) "horizontally", NULL
15833 };
15834
15835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15837 if (!SWIG_IsOK(res1)) {
15838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15839 }
15840 arg1 = reinterpret_cast< wxImage * >(argp1);
15841 if (obj1) {
15842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15843 if (!SWIG_IsOK(ecode2)) {
15844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15845 }
15846 arg2 = static_cast< bool >(val2);
15847 }
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 result = (arg1)->Mirror(arg2);
15851 wxPyEndAllowThreads(__tstate);
15852 if (PyErr_Occurred()) SWIG_fail;
15853 }
15854 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15855 return resultobj;
15856 fail:
15857 return NULL;
15858 }
15859
15860
15861 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15862 PyObject *resultobj = 0;
15863 wxImage *arg1 = (wxImage *) 0 ;
15864 byte arg2 ;
15865 byte arg3 ;
15866 byte arg4 ;
15867 byte arg5 ;
15868 byte arg6 ;
15869 byte arg7 ;
15870 void *argp1 = 0 ;
15871 int res1 = 0 ;
15872 unsigned char val2 ;
15873 int ecode2 = 0 ;
15874 unsigned char val3 ;
15875 int ecode3 = 0 ;
15876 unsigned char val4 ;
15877 int ecode4 = 0 ;
15878 unsigned char val5 ;
15879 int ecode5 = 0 ;
15880 unsigned char val6 ;
15881 int ecode6 = 0 ;
15882 unsigned char val7 ;
15883 int ecode7 = 0 ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 PyObject * obj2 = 0 ;
15887 PyObject * obj3 = 0 ;
15888 PyObject * obj4 = 0 ;
15889 PyObject * obj5 = 0 ;
15890 PyObject * obj6 = 0 ;
15891 char * kwnames[] = {
15892 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15893 };
15894
15895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15899 }
15900 arg1 = reinterpret_cast< wxImage * >(argp1);
15901 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15902 if (!SWIG_IsOK(ecode2)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15904 }
15905 arg2 = static_cast< byte >(val2);
15906 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15907 if (!SWIG_IsOK(ecode3)) {
15908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15909 }
15910 arg3 = static_cast< byte >(val3);
15911 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15912 if (!SWIG_IsOK(ecode4)) {
15913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15914 }
15915 arg4 = static_cast< byte >(val4);
15916 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15917 if (!SWIG_IsOK(ecode5)) {
15918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15919 }
15920 arg5 = static_cast< byte >(val5);
15921 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15922 if (!SWIG_IsOK(ecode6)) {
15923 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15924 }
15925 arg6 = static_cast< byte >(val6);
15926 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15927 if (!SWIG_IsOK(ecode7)) {
15928 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15929 }
15930 arg7 = static_cast< byte >(val7);
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15934 wxPyEndAllowThreads(__tstate);
15935 if (PyErr_Occurred()) SWIG_fail;
15936 }
15937 resultobj = SWIG_Py_Void();
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15945 PyObject *resultobj = 0;
15946 wxImage *arg1 = (wxImage *) 0 ;
15947 double arg2 = (double) 0.299 ;
15948 double arg3 = (double) 0.587 ;
15949 double arg4 = (double) 0.114 ;
15950 SwigValueWrapper<wxImage > result;
15951 void *argp1 = 0 ;
15952 int res1 = 0 ;
15953 double val2 ;
15954 int ecode2 = 0 ;
15955 double val3 ;
15956 int ecode3 = 0 ;
15957 double val4 ;
15958 int ecode4 = 0 ;
15959 PyObject * obj0 = 0 ;
15960 PyObject * obj1 = 0 ;
15961 PyObject * obj2 = 0 ;
15962 PyObject * obj3 = 0 ;
15963 char * kwnames[] = {
15964 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15965 };
15966
15967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15969 if (!SWIG_IsOK(res1)) {
15970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15971 }
15972 arg1 = reinterpret_cast< wxImage * >(argp1);
15973 if (obj1) {
15974 ecode2 = SWIG_AsVal_double(obj1, &val2);
15975 if (!SWIG_IsOK(ecode2)) {
15976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15977 }
15978 arg2 = static_cast< double >(val2);
15979 }
15980 if (obj2) {
15981 ecode3 = SWIG_AsVal_double(obj2, &val3);
15982 if (!SWIG_IsOK(ecode3)) {
15983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15984 }
15985 arg3 = static_cast< double >(val3);
15986 }
15987 if (obj3) {
15988 ecode4 = SWIG_AsVal_double(obj3, &val4);
15989 if (!SWIG_IsOK(ecode4)) {
15990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
15991 }
15992 arg4 = static_cast< double >(val4);
15993 }
15994 {
15995 PyThreadState* __tstate = wxPyBeginAllowThreads();
15996 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
15997 wxPyEndAllowThreads(__tstate);
15998 if (PyErr_Occurred()) SWIG_fail;
15999 }
16000 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj = 0;
16009 wxImage *arg1 = (wxImage *) 0 ;
16010 byte arg2 ;
16011 byte arg3 ;
16012 byte arg4 ;
16013 SwigValueWrapper<wxImage > result;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 unsigned char val2 ;
16017 int ecode2 = 0 ;
16018 unsigned char val3 ;
16019 int ecode3 = 0 ;
16020 unsigned char val4 ;
16021 int ecode4 = 0 ;
16022 PyObject * obj0 = 0 ;
16023 PyObject * obj1 = 0 ;
16024 PyObject * obj2 = 0 ;
16025 PyObject * obj3 = 0 ;
16026 char * kwnames[] = {
16027 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16028 };
16029
16030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16032 if (!SWIG_IsOK(res1)) {
16033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16034 }
16035 arg1 = reinterpret_cast< wxImage * >(argp1);
16036 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16037 if (!SWIG_IsOK(ecode2)) {
16038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16039 }
16040 arg2 = static_cast< byte >(val2);
16041 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16042 if (!SWIG_IsOK(ecode3)) {
16043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16044 }
16045 arg3 = static_cast< byte >(val3);
16046 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16047 if (!SWIG_IsOK(ecode4)) {
16048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16049 }
16050 arg4 = static_cast< byte >(val4);
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj = 0;
16066 wxImage *arg1 = (wxImage *) 0 ;
16067 wxString *arg2 = 0 ;
16068 wxString *arg3 = 0 ;
16069 void *argp1 = 0 ;
16070 int res1 = 0 ;
16071 bool temp2 = false ;
16072 bool temp3 = false ;
16073 PyObject * obj0 = 0 ;
16074 PyObject * obj1 = 0 ;
16075 PyObject * obj2 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "self",(char *) "name",(char *) "value", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16082 if (!SWIG_IsOK(res1)) {
16083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16084 }
16085 arg1 = reinterpret_cast< wxImage * >(argp1);
16086 {
16087 arg2 = wxString_in_helper(obj1);
16088 if (arg2 == NULL) SWIG_fail;
16089 temp2 = true;
16090 }
16091 {
16092 arg3 = wxString_in_helper(obj2);
16093 if (arg3 == NULL) SWIG_fail;
16094 temp3 = true;
16095 }
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_Py_Void();
16103 {
16104 if (temp2)
16105 delete arg2;
16106 }
16107 {
16108 if (temp3)
16109 delete arg3;
16110 }
16111 return resultobj;
16112 fail:
16113 {
16114 if (temp2)
16115 delete arg2;
16116 }
16117 {
16118 if (temp3)
16119 delete arg3;
16120 }
16121 return NULL;
16122 }
16123
16124
16125 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj = 0;
16127 wxImage *arg1 = (wxImage *) 0 ;
16128 wxString *arg2 = 0 ;
16129 int arg3 ;
16130 void *argp1 = 0 ;
16131 int res1 = 0 ;
16132 bool temp2 = false ;
16133 int val3 ;
16134 int ecode3 = 0 ;
16135 PyObject * obj0 = 0 ;
16136 PyObject * obj1 = 0 ;
16137 PyObject * obj2 = 0 ;
16138 char * kwnames[] = {
16139 (char *) "self",(char *) "name",(char *) "value", NULL
16140 };
16141
16142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16144 if (!SWIG_IsOK(res1)) {
16145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16146 }
16147 arg1 = reinterpret_cast< wxImage * >(argp1);
16148 {
16149 arg2 = wxString_in_helper(obj1);
16150 if (arg2 == NULL) SWIG_fail;
16151 temp2 = true;
16152 }
16153 ecode3 = SWIG_AsVal_int(obj2, &val3);
16154 if (!SWIG_IsOK(ecode3)) {
16155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16156 }
16157 arg3 = static_cast< int >(val3);
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 (arg1)->SetOption((wxString const &)*arg2,arg3);
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 resultobj = SWIG_Py_Void();
16165 {
16166 if (temp2)
16167 delete arg2;
16168 }
16169 return resultobj;
16170 fail:
16171 {
16172 if (temp2)
16173 delete arg2;
16174 }
16175 return NULL;
16176 }
16177
16178
16179 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16180 PyObject *resultobj = 0;
16181 wxImage *arg1 = (wxImage *) 0 ;
16182 wxString *arg2 = 0 ;
16183 wxString result;
16184 void *argp1 = 0 ;
16185 int res1 = 0 ;
16186 bool temp2 = false ;
16187 PyObject * obj0 = 0 ;
16188 PyObject * obj1 = 0 ;
16189 char * kwnames[] = {
16190 (char *) "self",(char *) "name", NULL
16191 };
16192
16193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16195 if (!SWIG_IsOK(res1)) {
16196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16197 }
16198 arg1 = reinterpret_cast< wxImage * >(argp1);
16199 {
16200 arg2 = wxString_in_helper(obj1);
16201 if (arg2 == NULL) SWIG_fail;
16202 temp2 = true;
16203 }
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16207 wxPyEndAllowThreads(__tstate);
16208 if (PyErr_Occurred()) SWIG_fail;
16209 }
16210 {
16211 #if wxUSE_UNICODE
16212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16213 #else
16214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16215 #endif
16216 }
16217 {
16218 if (temp2)
16219 delete arg2;
16220 }
16221 return resultobj;
16222 fail:
16223 {
16224 if (temp2)
16225 delete arg2;
16226 }
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 wxString *arg2 = 0 ;
16235 int result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 bool temp2 = false ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 char * kwnames[] = {
16242 (char *) "self",(char *) "name", NULL
16243 };
16244
16245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16247 if (!SWIG_IsOK(res1)) {
16248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16249 }
16250 arg1 = reinterpret_cast< wxImage * >(argp1);
16251 {
16252 arg2 = wxString_in_helper(obj1);
16253 if (arg2 == NULL) SWIG_fail;
16254 temp2 = true;
16255 }
16256 {
16257 PyThreadState* __tstate = wxPyBeginAllowThreads();
16258 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 resultobj = SWIG_From_int(static_cast< int >(result));
16263 {
16264 if (temp2)
16265 delete arg2;
16266 }
16267 return resultobj;
16268 fail:
16269 {
16270 if (temp2)
16271 delete arg2;
16272 }
16273 return NULL;
16274 }
16275
16276
16277 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16278 PyObject *resultobj = 0;
16279 wxImage *arg1 = (wxImage *) 0 ;
16280 wxString *arg2 = 0 ;
16281 bool result;
16282 void *argp1 = 0 ;
16283 int res1 = 0 ;
16284 bool temp2 = false ;
16285 PyObject * obj0 = 0 ;
16286 PyObject * obj1 = 0 ;
16287 char * kwnames[] = {
16288 (char *) "self",(char *) "name", NULL
16289 };
16290
16291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16293 if (!SWIG_IsOK(res1)) {
16294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16295 }
16296 arg1 = reinterpret_cast< wxImage * >(argp1);
16297 {
16298 arg2 = wxString_in_helper(obj1);
16299 if (arg2 == NULL) SWIG_fail;
16300 temp2 = true;
16301 }
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16310 }
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 return resultobj;
16316 fail:
16317 {
16318 if (temp2)
16319 delete arg2;
16320 }
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16329 unsigned long result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 unsigned long val2 ;
16333 int ecode2 = 0 ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 char * kwnames[] = {
16337 (char *) "self",(char *) "stopafter", NULL
16338 };
16339
16340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16344 }
16345 arg1 = reinterpret_cast< wxImage * >(argp1);
16346 if (obj1) {
16347 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16348 if (!SWIG_IsOK(ecode2)) {
16349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16350 }
16351 arg2 = static_cast< unsigned long >(val2);
16352 }
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 result = (unsigned long)(arg1)->CountColours(arg2);
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16367 PyObject *resultobj = 0;
16368 wxImage *arg1 = (wxImage *) 0 ;
16369 wxImageHistogram *arg2 = 0 ;
16370 unsigned long result;
16371 void *argp1 = 0 ;
16372 int res1 = 0 ;
16373 void *argp2 = 0 ;
16374 int res2 = 0 ;
16375 PyObject * obj0 = 0 ;
16376 PyObject * obj1 = 0 ;
16377 char * kwnames[] = {
16378 (char *) "self",(char *) "h", NULL
16379 };
16380
16381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16383 if (!SWIG_IsOK(res1)) {
16384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16385 }
16386 arg1 = reinterpret_cast< wxImage * >(argp1);
16387 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16388 if (!SWIG_IsOK(res2)) {
16389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16390 }
16391 if (!argp2) {
16392 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16393 }
16394 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj = 0;
16410 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16411 void *argp1 = 0 ;
16412 int res1 = 0 ;
16413 PyObject * obj0 = 0 ;
16414 char * kwnames[] = {
16415 (char *) "handler", NULL
16416 };
16417
16418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16420 if (!SWIG_IsOK(res1)) {
16421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16422 }
16423 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 wxImage::AddHandler(arg1);
16427 wxPyEndAllowThreads(__tstate);
16428 if (PyErr_Occurred()) SWIG_fail;
16429 }
16430 resultobj = SWIG_Py_Void();
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj = 0;
16439 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16440 void *argp1 = 0 ;
16441 int res1 = 0 ;
16442 PyObject * obj0 = 0 ;
16443 char * kwnames[] = {
16444 (char *) "handler", NULL
16445 };
16446
16447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16449 if (!SWIG_IsOK(res1)) {
16450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16451 }
16452 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16453 {
16454 PyThreadState* __tstate = wxPyBeginAllowThreads();
16455 wxImage::InsertHandler(arg1);
16456 wxPyEndAllowThreads(__tstate);
16457 if (PyErr_Occurred()) SWIG_fail;
16458 }
16459 resultobj = SWIG_Py_Void();
16460 return resultobj;
16461 fail:
16462 return NULL;
16463 }
16464
16465
16466 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj = 0;
16468 wxString *arg1 = 0 ;
16469 bool result;
16470 bool temp1 = false ;
16471 PyObject * obj0 = 0 ;
16472 char * kwnames[] = {
16473 (char *) "name", NULL
16474 };
16475
16476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16477 {
16478 arg1 = wxString_in_helper(obj0);
16479 if (arg1 == NULL) SWIG_fail;
16480 temp1 = true;
16481 }
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 {
16489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16490 }
16491 {
16492 if (temp1)
16493 delete arg1;
16494 }
16495 return resultobj;
16496 fail:
16497 {
16498 if (temp1)
16499 delete arg1;
16500 }
16501 return NULL;
16502 }
16503
16504
16505 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16506 PyObject *resultobj = 0;
16507 PyObject *result = 0 ;
16508
16509 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (PyObject *)wxImage_GetHandlers();
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 resultobj = result;
16517 return resultobj;
16518 fail:
16519 return NULL;
16520 }
16521
16522
16523 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16524 PyObject *resultobj = 0;
16525 wxString result;
16526
16527 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 result = wxImage::GetImageExtWildcard();
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 {
16535 #if wxUSE_UNICODE
16536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16537 #else
16538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16539 #endif
16540 }
16541 return resultobj;
16542 fail:
16543 return NULL;
16544 }
16545
16546
16547 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16548 PyObject *resultobj = 0;
16549 wxImage *arg1 = (wxImage *) 0 ;
16550 int arg2 = (int) -1 ;
16551 wxBitmap result;
16552 void *argp1 = 0 ;
16553 int res1 = 0 ;
16554 int val2 ;
16555 int ecode2 = 0 ;
16556 PyObject * obj0 = 0 ;
16557 PyObject * obj1 = 0 ;
16558 char * kwnames[] = {
16559 (char *) "self",(char *) "depth", NULL
16560 };
16561
16562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16566 }
16567 arg1 = reinterpret_cast< wxImage * >(argp1);
16568 if (obj1) {
16569 ecode2 = SWIG_AsVal_int(obj1, &val2);
16570 if (!SWIG_IsOK(ecode2)) {
16571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16572 }
16573 arg2 = static_cast< int >(val2);
16574 }
16575 {
16576 if (!wxPyCheckForApp()) SWIG_fail;
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 result = wxImage_ConvertToBitmap(arg1,arg2);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxImage *arg1 = (wxImage *) 0 ;
16592 byte arg2 ;
16593 byte arg3 ;
16594 byte arg4 ;
16595 wxBitmap result;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 unsigned char val2 ;
16599 int ecode2 = 0 ;
16600 unsigned char val3 ;
16601 int ecode3 = 0 ;
16602 unsigned char val4 ;
16603 int ecode4 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 PyObject * obj2 = 0 ;
16607 PyObject * obj3 = 0 ;
16608 char * kwnames[] = {
16609 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16610 };
16611
16612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16614 if (!SWIG_IsOK(res1)) {
16615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16616 }
16617 arg1 = reinterpret_cast< wxImage * >(argp1);
16618 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16619 if (!SWIG_IsOK(ecode2)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16621 }
16622 arg2 = static_cast< byte >(val2);
16623 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16624 if (!SWIG_IsOK(ecode3)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16626 }
16627 arg3 = static_cast< byte >(val3);
16628 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16629 if (!SWIG_IsOK(ecode4)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16631 }
16632 arg4 = static_cast< byte >(val4);
16633 {
16634 if (!wxPyCheckForApp()) SWIG_fail;
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxImage *arg1 = (wxImage *) 0 ;
16650 double arg2 ;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 double val2 ;
16654 int ecode2 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "angle", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16665 }
16666 arg1 = reinterpret_cast< wxImage * >(argp1);
16667 ecode2 = SWIG_AsVal_double(obj1, &val2);
16668 if (!SWIG_IsOK(ecode2)) {
16669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16670 }
16671 arg2 = static_cast< double >(val2);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 (arg1)->RotateHue(arg2);
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_Py_Void();
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16686 PyObject *resultobj = 0;
16687 wxImage_RGBValue arg1 ;
16688 wxImage_HSVValue result;
16689 void *argp1 ;
16690 int res1 = 0 ;
16691 PyObject * obj0 = 0 ;
16692 char * kwnames[] = {
16693 (char *) "rgb", NULL
16694 };
16695
16696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16697 {
16698 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16699 if (!SWIG_IsOK(res1)) {
16700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16701 }
16702 if (!argp1) {
16703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16704 } else {
16705 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16706 arg1 = *temp;
16707 if (SWIG_IsNewObj(res1)) delete temp;
16708 }
16709 }
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 result = wxImage::RGBtoHSV(arg1);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxImage_HSVValue arg1 ;
16726 wxImage_RGBValue result;
16727 void *argp1 ;
16728 int res1 = 0 ;
16729 PyObject * obj0 = 0 ;
16730 char * kwnames[] = {
16731 (char *) "hsv", NULL
16732 };
16733
16734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16735 {
16736 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16737 if (!SWIG_IsOK(res1)) {
16738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16739 }
16740 if (!argp1) {
16741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16742 } else {
16743 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16744 arg1 = *temp;
16745 if (SWIG_IsNewObj(res1)) delete temp;
16746 }
16747 }
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 result = wxImage::HSVtoRGB(arg1);
16751 wxPyEndAllowThreads(__tstate);
16752 if (PyErr_Occurred()) SWIG_fail;
16753 }
16754 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16755 return resultobj;
16756 fail:
16757 return NULL;
16758 }
16759
16760
16761 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16762 PyObject *obj;
16763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16764 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16765 return SWIG_Py_Void();
16766 }
16767
16768 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16769 return SWIG_Python_InitShadowInstance(args);
16770 }
16771
16772 SWIGINTERN int NullImage_set(PyObject *) {
16773 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16774 return 1;
16775 }
16776
16777
16778 SWIGINTERN PyObject *NullImage_get(void) {
16779 PyObject *pyobj = 0;
16780
16781 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16782 return pyobj;
16783 }
16784
16785
16786 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16787 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16788 return 1;
16789 }
16790
16791
16792 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16793 PyObject *pyobj = 0;
16794
16795 {
16796 #if wxUSE_UNICODE
16797 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16798 #else
16799 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16800 #endif
16801 }
16802 return pyobj;
16803 }
16804
16805
16806 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16807 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16808 return 1;
16809 }
16810
16811
16812 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16813 PyObject *pyobj = 0;
16814
16815 {
16816 #if wxUSE_UNICODE
16817 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16818 #else
16819 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16820 #endif
16821 }
16822 return pyobj;
16823 }
16824
16825
16826 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16827 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16828 return 1;
16829 }
16830
16831
16832 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16833 PyObject *pyobj = 0;
16834
16835 {
16836 #if wxUSE_UNICODE
16837 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16838 #else
16839 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16840 #endif
16841 }
16842 return pyobj;
16843 }
16844
16845
16846 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16847 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16848 return 1;
16849 }
16850
16851
16852 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16853 PyObject *pyobj = 0;
16854
16855 {
16856 #if wxUSE_UNICODE
16857 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16858 #else
16859 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16860 #endif
16861 }
16862 return pyobj;
16863 }
16864
16865
16866 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16867 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16868 return 1;
16869 }
16870
16871
16872 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16873 PyObject *pyobj = 0;
16874
16875 {
16876 #if wxUSE_UNICODE
16877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16878 #else
16879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16880 #endif
16881 }
16882 return pyobj;
16883 }
16884
16885
16886 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16887 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16888 return 1;
16889 }
16890
16891
16892 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16893 PyObject *pyobj = 0;
16894
16895 {
16896 #if wxUSE_UNICODE
16897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16898 #else
16899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16900 #endif
16901 }
16902 return pyobj;
16903 }
16904
16905
16906 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16907 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16908 return 1;
16909 }
16910
16911
16912 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16913 PyObject *pyobj = 0;
16914
16915 {
16916 #if wxUSE_UNICODE
16917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16918 #else
16919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16920 #endif
16921 }
16922 return pyobj;
16923 }
16924
16925
16926 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16928 return 1;
16929 }
16930
16931
16932 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16933 PyObject *pyobj = 0;
16934
16935 {
16936 #if wxUSE_UNICODE
16937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16938 #else
16939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16940 #endif
16941 }
16942 return pyobj;
16943 }
16944
16945
16946 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16948 return 1;
16949 }
16950
16951
16952 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16953 PyObject *pyobj = 0;
16954
16955 {
16956 #if wxUSE_UNICODE
16957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16958 #else
16959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16960 #endif
16961 }
16962 return pyobj;
16963 }
16964
16965
16966 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16968 return 1;
16969 }
16970
16971
16972 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16973 PyObject *pyobj = 0;
16974
16975 {
16976 #if wxUSE_UNICODE
16977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16978 #else
16979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16980 #endif
16981 }
16982 return pyobj;
16983 }
16984
16985
16986 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16988 return 1;
16989 }
16990
16991
16992 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
16993 PyObject *pyobj = 0;
16994
16995 {
16996 #if wxUSE_UNICODE
16997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
16998 #else
16999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17000 #endif
17001 }
17002 return pyobj;
17003 }
17004
17005
17006 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17008 return 1;
17009 }
17010
17011
17012 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17013 PyObject *pyobj = 0;
17014
17015 {
17016 #if wxUSE_UNICODE
17017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17018 #else
17019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17020 #endif
17021 }
17022 return pyobj;
17023 }
17024
17025
17026 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17028 return 1;
17029 }
17030
17031
17032 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17033 PyObject *pyobj = 0;
17034
17035 {
17036 #if wxUSE_UNICODE
17037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17038 #else
17039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17040 #endif
17041 }
17042 return pyobj;
17043 }
17044
17045
17046 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17048 return 1;
17049 }
17050
17051
17052 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17053 PyObject *pyobj = 0;
17054
17055 {
17056 #if wxUSE_UNICODE
17057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17058 #else
17059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17060 #endif
17061 }
17062 return pyobj;
17063 }
17064
17065
17066 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17068 return 1;
17069 }
17070
17071
17072 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17073 PyObject *pyobj = 0;
17074
17075 {
17076 #if wxUSE_UNICODE
17077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17078 #else
17079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17080 #endif
17081 }
17082 return pyobj;
17083 }
17084
17085
17086 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17087 PyObject *resultobj = 0;
17088 wxBMPHandler *result = 0 ;
17089
17090 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = (wxBMPHandler *)new wxBMPHandler();
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17105 PyObject *obj;
17106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17107 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17108 return SWIG_Py_Void();
17109 }
17110
17111 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17112 return SWIG_Python_InitShadowInstance(args);
17113 }
17114
17115 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17116 PyObject *resultobj = 0;
17117 wxICOHandler *result = 0 ;
17118
17119 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17120 {
17121 PyThreadState* __tstate = wxPyBeginAllowThreads();
17122 result = (wxICOHandler *)new wxICOHandler();
17123 wxPyEndAllowThreads(__tstate);
17124 if (PyErr_Occurred()) SWIG_fail;
17125 }
17126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17127 return resultobj;
17128 fail:
17129 return NULL;
17130 }
17131
17132
17133 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17134 PyObject *obj;
17135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17136 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17137 return SWIG_Py_Void();
17138 }
17139
17140 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17141 return SWIG_Python_InitShadowInstance(args);
17142 }
17143
17144 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17145 PyObject *resultobj = 0;
17146 wxCURHandler *result = 0 ;
17147
17148 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17149 {
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (wxCURHandler *)new wxCURHandler();
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17156 return resultobj;
17157 fail:
17158 return NULL;
17159 }
17160
17161
17162 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17163 PyObject *obj;
17164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17165 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17166 return SWIG_Py_Void();
17167 }
17168
17169 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17170 return SWIG_Python_InitShadowInstance(args);
17171 }
17172
17173 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17174 PyObject *resultobj = 0;
17175 wxANIHandler *result = 0 ;
17176
17177 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17178 {
17179 PyThreadState* __tstate = wxPyBeginAllowThreads();
17180 result = (wxANIHandler *)new wxANIHandler();
17181 wxPyEndAllowThreads(__tstate);
17182 if (PyErr_Occurred()) SWIG_fail;
17183 }
17184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17185 return resultobj;
17186 fail:
17187 return NULL;
17188 }
17189
17190
17191 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17192 PyObject *obj;
17193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17194 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17195 return SWIG_Py_Void();
17196 }
17197
17198 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17199 return SWIG_Python_InitShadowInstance(args);
17200 }
17201
17202 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17203 PyObject *resultobj = 0;
17204 wxPNGHandler *result = 0 ;
17205
17206 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (wxPNGHandler *)new wxPNGHandler();
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17221 PyObject *obj;
17222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17223 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17224 return SWIG_Py_Void();
17225 }
17226
17227 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17228 return SWIG_Python_InitShadowInstance(args);
17229 }
17230
17231 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17232 PyObject *resultobj = 0;
17233 wxGIFHandler *result = 0 ;
17234
17235 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17236 {
17237 PyThreadState* __tstate = wxPyBeginAllowThreads();
17238 result = (wxGIFHandler *)new wxGIFHandler();
17239 wxPyEndAllowThreads(__tstate);
17240 if (PyErr_Occurred()) SWIG_fail;
17241 }
17242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17250 PyObject *obj;
17251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17252 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17253 return SWIG_Py_Void();
17254 }
17255
17256 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17257 return SWIG_Python_InitShadowInstance(args);
17258 }
17259
17260 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17261 PyObject *resultobj = 0;
17262 wxPCXHandler *result = 0 ;
17263
17264 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17265 {
17266 PyThreadState* __tstate = wxPyBeginAllowThreads();
17267 result = (wxPCXHandler *)new wxPCXHandler();
17268 wxPyEndAllowThreads(__tstate);
17269 if (PyErr_Occurred()) SWIG_fail;
17270 }
17271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17272 return resultobj;
17273 fail:
17274 return NULL;
17275 }
17276
17277
17278 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279 PyObject *obj;
17280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17282 return SWIG_Py_Void();
17283 }
17284
17285 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17286 return SWIG_Python_InitShadowInstance(args);
17287 }
17288
17289 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17290 PyObject *resultobj = 0;
17291 wxJPEGHandler *result = 0 ;
17292
17293 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (wxJPEGHandler *)new wxJPEGHandler();
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17308 PyObject *obj;
17309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17310 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17311 return SWIG_Py_Void();
17312 }
17313
17314 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17315 return SWIG_Python_InitShadowInstance(args);
17316 }
17317
17318 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 PyObject *resultobj = 0;
17320 wxPNMHandler *result = 0 ;
17321
17322 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 result = (wxPNMHandler *)new wxPNMHandler();
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 PyObject *obj;
17338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17339 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17340 return SWIG_Py_Void();
17341 }
17342
17343 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17344 return SWIG_Python_InitShadowInstance(args);
17345 }
17346
17347 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 PyObject *resultobj = 0;
17349 wxXPMHandler *result = 0 ;
17350
17351 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (wxXPMHandler *)new wxXPMHandler();
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17359 return resultobj;
17360 fail:
17361 return NULL;
17362 }
17363
17364
17365 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17366 PyObject *obj;
17367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17368 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17369 return SWIG_Py_Void();
17370 }
17371
17372 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17373 return SWIG_Python_InitShadowInstance(args);
17374 }
17375
17376 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 PyObject *resultobj = 0;
17378 wxTIFFHandler *result = 0 ;
17379
17380 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 result = (wxTIFFHandler *)new wxTIFFHandler();
17384 wxPyEndAllowThreads(__tstate);
17385 if (PyErr_Occurred()) SWIG_fail;
17386 }
17387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17388 return resultobj;
17389 fail:
17390 return NULL;
17391 }
17392
17393
17394 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17395 PyObject *obj;
17396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17397 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17398 return SWIG_Py_Void();
17399 }
17400
17401 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17402 return SWIG_Python_InitShadowInstance(args);
17403 }
17404
17405 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17406 PyObject *resultobj = 0;
17407 wxImage *arg1 = 0 ;
17408 wxImage *arg2 = 0 ;
17409 int arg3 = (int) 236 ;
17410 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17411 bool result;
17412 void *argp1 = 0 ;
17413 int res1 = 0 ;
17414 void *argp2 = 0 ;
17415 int res2 = 0 ;
17416 int val3 ;
17417 int ecode3 = 0 ;
17418 int val4 ;
17419 int ecode4 = 0 ;
17420 PyObject * obj0 = 0 ;
17421 PyObject * obj1 = 0 ;
17422 PyObject * obj2 = 0 ;
17423 PyObject * obj3 = 0 ;
17424 char * kwnames[] = {
17425 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17426 };
17427
17428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17429 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17430 if (!SWIG_IsOK(res1)) {
17431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17432 }
17433 if (!argp1) {
17434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17435 }
17436 arg1 = reinterpret_cast< wxImage * >(argp1);
17437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17438 if (!SWIG_IsOK(res2)) {
17439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17440 }
17441 if (!argp2) {
17442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17443 }
17444 arg2 = reinterpret_cast< wxImage * >(argp2);
17445 if (obj2) {
17446 ecode3 = SWIG_AsVal_int(obj2, &val3);
17447 if (!SWIG_IsOK(ecode3)) {
17448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17449 }
17450 arg3 = static_cast< int >(val3);
17451 }
17452 if (obj3) {
17453 ecode4 = SWIG_AsVal_int(obj3, &val4);
17454 if (!SWIG_IsOK(ecode4)) {
17455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17456 }
17457 arg4 = static_cast< int >(val4);
17458 }
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 {
17466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17467 }
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 PyObject *obj;
17476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17477 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17478 return SWIG_Py_Void();
17479 }
17480
17481 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17482 PyObject *resultobj = 0;
17483 wxEvtHandler *result = 0 ;
17484
17485 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (wxEvtHandler *)new wxEvtHandler();
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17500 PyObject *resultobj = 0;
17501 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17502 wxEvtHandler *result = 0 ;
17503 void *argp1 = 0 ;
17504 int res1 = 0 ;
17505 PyObject *swig_obj[1] ;
17506
17507 if (!args) SWIG_fail;
17508 swig_obj[0] = args;
17509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17510 if (!SWIG_IsOK(res1)) {
17511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17512 }
17513 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 {
17521 resultobj = wxPyMake_wxObject(result, 0);
17522 }
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17530 PyObject *resultobj = 0;
17531 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17532 wxEvtHandler *result = 0 ;
17533 void *argp1 = 0 ;
17534 int res1 = 0 ;
17535 PyObject *swig_obj[1] ;
17536
17537 if (!args) SWIG_fail;
17538 swig_obj[0] = args;
17539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17540 if (!SWIG_IsOK(res1)) {
17541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17542 }
17543 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 {
17551 resultobj = wxPyMake_wxObject(result, 0);
17552 }
17553 return resultobj;
17554 fail:
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17563 void *argp1 = 0 ;
17564 int res1 = 0 ;
17565 void *argp2 = 0 ;
17566 int res2 = 0 ;
17567 PyObject * obj0 = 0 ;
17568 PyObject * obj1 = 0 ;
17569 char * kwnames[] = {
17570 (char *) "self",(char *) "handler", NULL
17571 };
17572
17573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17577 }
17578 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17580 if (!SWIG_IsOK(res2)) {
17581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17582 }
17583 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17584 {
17585 PyThreadState* __tstate = wxPyBeginAllowThreads();
17586 (arg1)->SetNextHandler(arg2);
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 resultobj = SWIG_Py_Void();
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = 0;
17599 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17600 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17601 void *argp1 = 0 ;
17602 int res1 = 0 ;
17603 void *argp2 = 0 ;
17604 int res2 = 0 ;
17605 PyObject * obj0 = 0 ;
17606 PyObject * obj1 = 0 ;
17607 char * kwnames[] = {
17608 (char *) "self",(char *) "handler", NULL
17609 };
17610
17611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17613 if (!SWIG_IsOK(res1)) {
17614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17615 }
17616 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17618 if (!SWIG_IsOK(res2)) {
17619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17620 }
17621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 (arg1)->SetPreviousHandler(arg2);
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 resultobj = SWIG_Py_Void();
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *resultobj = 0;
17637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17638 bool result;
17639 void *argp1 = 0 ;
17640 int res1 = 0 ;
17641 PyObject *swig_obj[1] ;
17642
17643 if (!args) SWIG_fail;
17644 swig_obj[0] = args;
17645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17646 if (!SWIG_IsOK(res1)) {
17647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17648 }
17649 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)(arg1)->GetEvtHandlerEnabled();
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 {
17657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17658 }
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj = 0;
17667 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17668 bool arg2 ;
17669 void *argp1 = 0 ;
17670 int res1 = 0 ;
17671 bool val2 ;
17672 int ecode2 = 0 ;
17673 PyObject * obj0 = 0 ;
17674 PyObject * obj1 = 0 ;
17675 char * kwnames[] = {
17676 (char *) "self",(char *) "enabled", NULL
17677 };
17678
17679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17681 if (!SWIG_IsOK(res1)) {
17682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17683 }
17684 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17685 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17686 if (!SWIG_IsOK(ecode2)) {
17687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17688 }
17689 arg2 = static_cast< bool >(val2);
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 (arg1)->SetEvtHandlerEnabled(arg2);
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 resultobj = SWIG_Py_Void();
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj = 0;
17705 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17706 wxEvent *arg2 = 0 ;
17707 bool result;
17708 void *argp1 = 0 ;
17709 int res1 = 0 ;
17710 void *argp2 = 0 ;
17711 int res2 = 0 ;
17712 PyObject * obj0 = 0 ;
17713 PyObject * obj1 = 0 ;
17714 char * kwnames[] = {
17715 (char *) "self",(char *) "event", NULL
17716 };
17717
17718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17720 if (!SWIG_IsOK(res1)) {
17721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17722 }
17723 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17725 if (!SWIG_IsOK(res2)) {
17726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17727 }
17728 if (!argp2) {
17729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17730 }
17731 arg2 = reinterpret_cast< wxEvent * >(argp2);
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = (bool)(arg1)->ProcessEvent(*arg2);
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 {
17739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17740 }
17741 return resultobj;
17742 fail:
17743 return NULL;
17744 }
17745
17746
17747 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17748 PyObject *resultobj = 0;
17749 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17750 wxEvent *arg2 = 0 ;
17751 void *argp1 = 0 ;
17752 int res1 = 0 ;
17753 void *argp2 = 0 ;
17754 int res2 = 0 ;
17755 PyObject * obj0 = 0 ;
17756 PyObject * obj1 = 0 ;
17757 char * kwnames[] = {
17758 (char *) "self",(char *) "event", NULL
17759 };
17760
17761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17763 if (!SWIG_IsOK(res1)) {
17764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17765 }
17766 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17768 if (!SWIG_IsOK(res2)) {
17769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17770 }
17771 if (!argp2) {
17772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17773 }
17774 arg2 = reinterpret_cast< wxEvent * >(argp2);
17775 {
17776 PyThreadState* __tstate = wxPyBeginAllowThreads();
17777 (arg1)->AddPendingEvent(*arg2);
17778 wxPyEndAllowThreads(__tstate);
17779 if (PyErr_Occurred()) SWIG_fail;
17780 }
17781 resultobj = SWIG_Py_Void();
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17789 PyObject *resultobj = 0;
17790 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17791 void *argp1 = 0 ;
17792 int res1 = 0 ;
17793 PyObject *swig_obj[1] ;
17794
17795 if (!args) SWIG_fail;
17796 swig_obj[0] = args;
17797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17798 if (!SWIG_IsOK(res1)) {
17799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17800 }
17801 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 (arg1)->ProcessPendingEvents();
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 resultobj = SWIG_Py_Void();
17809 return resultobj;
17810 fail:
17811 return NULL;
17812 }
17813
17814
17815 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17816 PyObject *resultobj = 0;
17817 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17818 int arg2 ;
17819 int arg3 ;
17820 int arg4 ;
17821 PyObject *arg5 = (PyObject *) 0 ;
17822 void *argp1 = 0 ;
17823 int res1 = 0 ;
17824 int val2 ;
17825 int ecode2 = 0 ;
17826 int val3 ;
17827 int ecode3 = 0 ;
17828 int val4 ;
17829 int ecode4 = 0 ;
17830 PyObject * obj0 = 0 ;
17831 PyObject * obj1 = 0 ;
17832 PyObject * obj2 = 0 ;
17833 PyObject * obj3 = 0 ;
17834 PyObject * obj4 = 0 ;
17835 char * kwnames[] = {
17836 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17837 };
17838
17839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17841 if (!SWIG_IsOK(res1)) {
17842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17843 }
17844 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17845 ecode2 = SWIG_AsVal_int(obj1, &val2);
17846 if (!SWIG_IsOK(ecode2)) {
17847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17848 }
17849 arg2 = static_cast< int >(val2);
17850 ecode3 = SWIG_AsVal_int(obj2, &val3);
17851 if (!SWIG_IsOK(ecode3)) {
17852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17853 }
17854 arg3 = static_cast< int >(val3);
17855 ecode4 = SWIG_AsVal_int(obj3, &val4);
17856 if (!SWIG_IsOK(ecode4)) {
17857 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17858 }
17859 arg4 = static_cast< int >(val4);
17860 arg5 = obj4;
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 resultobj = SWIG_Py_Void();
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17875 PyObject *resultobj = 0;
17876 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17877 int arg2 ;
17878 int arg3 = (int) -1 ;
17879 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17880 bool result;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 int val2 ;
17884 int ecode2 = 0 ;
17885 int val3 ;
17886 int ecode3 = 0 ;
17887 int val4 ;
17888 int ecode4 = 0 ;
17889 PyObject * obj0 = 0 ;
17890 PyObject * obj1 = 0 ;
17891 PyObject * obj2 = 0 ;
17892 PyObject * obj3 = 0 ;
17893 char * kwnames[] = {
17894 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17895 };
17896
17897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17899 if (!SWIG_IsOK(res1)) {
17900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17901 }
17902 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17903 ecode2 = SWIG_AsVal_int(obj1, &val2);
17904 if (!SWIG_IsOK(ecode2)) {
17905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17906 }
17907 arg2 = static_cast< int >(val2);
17908 if (obj2) {
17909 ecode3 = SWIG_AsVal_int(obj2, &val3);
17910 if (!SWIG_IsOK(ecode3)) {
17911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17912 }
17913 arg3 = static_cast< int >(val3);
17914 }
17915 if (obj3) {
17916 ecode4 = SWIG_AsVal_int(obj3, &val4);
17917 if (!SWIG_IsOK(ecode4)) {
17918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17919 }
17920 arg4 = static_cast< wxEventType >(val4);
17921 }
17922 {
17923 PyThreadState* __tstate = wxPyBeginAllowThreads();
17924 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj = 0;
17939 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17940 PyObject *arg2 = (PyObject *) 0 ;
17941 bool arg3 = (bool) true ;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 bool val3 ;
17945 int ecode3 = 0 ;
17946 PyObject * obj0 = 0 ;
17947 PyObject * obj1 = 0 ;
17948 PyObject * obj2 = 0 ;
17949 char * kwnames[] = {
17950 (char *) "self",(char *) "_self",(char *) "incref", NULL
17951 };
17952
17953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17955 if (!SWIG_IsOK(res1)) {
17956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17957 }
17958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17959 arg2 = obj1;
17960 if (obj2) {
17961 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17962 if (!SWIG_IsOK(ecode3)) {
17963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17964 }
17965 arg3 = static_cast< bool >(val3);
17966 }
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 resultobj = SWIG_Py_Void();
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17981 PyObject *obj;
17982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17983 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17984 return SWIG_Py_Void();
17985 }
17986
17987 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17988 return SWIG_Python_InitShadowInstance(args);
17989 }
17990
17991 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17992 PyObject *resultobj = 0;
17993 wxEventType result;
17994
17995 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 result = (wxEventType)wxNewEventType();
17999 wxPyEndAllowThreads(__tstate);
18000 if (PyErr_Occurred()) SWIG_fail;
18001 }
18002 resultobj = SWIG_From_int(static_cast< int >(result));
18003 return resultobj;
18004 fail:
18005 return NULL;
18006 }
18007
18008
18009 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18010 PyObject *resultobj = 0;
18011 wxEvent *arg1 = (wxEvent *) 0 ;
18012 void *argp1 = 0 ;
18013 int res1 = 0 ;
18014 PyObject *swig_obj[1] ;
18015
18016 if (!args) SWIG_fail;
18017 swig_obj[0] = args;
18018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18019 if (!SWIG_IsOK(res1)) {
18020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18021 }
18022 arg1 = reinterpret_cast< wxEvent * >(argp1);
18023 {
18024 PyThreadState* __tstate = wxPyBeginAllowThreads();
18025 delete arg1;
18026
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 resultobj = SWIG_Py_Void();
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj = 0;
18039 wxEvent *arg1 = (wxEvent *) 0 ;
18040 wxEventType arg2 ;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 int val2 ;
18044 int ecode2 = 0 ;
18045 PyObject * obj0 = 0 ;
18046 PyObject * obj1 = 0 ;
18047 char * kwnames[] = {
18048 (char *) "self",(char *) "typ", NULL
18049 };
18050
18051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18053 if (!SWIG_IsOK(res1)) {
18054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18055 }
18056 arg1 = reinterpret_cast< wxEvent * >(argp1);
18057 ecode2 = SWIG_AsVal_int(obj1, &val2);
18058 if (!SWIG_IsOK(ecode2)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18060 }
18061 arg2 = static_cast< wxEventType >(val2);
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 (arg1)->SetEventType(arg2);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_Py_Void();
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxEvent *arg1 = (wxEvent *) 0 ;
18078 wxEventType result;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject *swig_obj[1] ;
18082
18083 if (!args) SWIG_fail;
18084 swig_obj[0] = args;
18085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18088 }
18089 arg1 = reinterpret_cast< wxEvent * >(argp1);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_From_int(static_cast< int >(result));
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18104 PyObject *resultobj = 0;
18105 wxEvent *arg1 = (wxEvent *) 0 ;
18106 wxObject *result = 0 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvent * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 {
18125 resultobj = wxPyMake_wxObject(result, (bool)0);
18126 }
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj = 0;
18135 wxEvent *arg1 = (wxEvent *) 0 ;
18136 wxObject *arg2 = (wxObject *) 0 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 void *argp2 = 0 ;
18140 int res2 = 0 ;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char * kwnames[] = {
18144 (char *) "self",(char *) "obj", NULL
18145 };
18146
18147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18149 if (!SWIG_IsOK(res1)) {
18150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18151 }
18152 arg1 = reinterpret_cast< wxEvent * >(argp1);
18153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18154 if (!SWIG_IsOK(res2)) {
18155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18156 }
18157 arg2 = reinterpret_cast< wxObject * >(argp2);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 (arg1)->SetEventObject(arg2);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = SWIG_Py_Void();
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxEvent *arg1 = (wxEvent *) 0 ;
18174 long result;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18184 }
18185 arg1 = reinterpret_cast< wxEvent * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_From_long(static_cast< long >(result));
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18200 PyObject *resultobj = 0;
18201 wxEvent *arg1 = (wxEvent *) 0 ;
18202 long arg2 = (long) 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 long val2 ;
18206 int ecode2 = 0 ;
18207 PyObject * obj0 = 0 ;
18208 PyObject * obj1 = 0 ;
18209 char * kwnames[] = {
18210 (char *) "self",(char *) "ts", NULL
18211 };
18212
18213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18215 if (!SWIG_IsOK(res1)) {
18216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18217 }
18218 arg1 = reinterpret_cast< wxEvent * >(argp1);
18219 if (obj1) {
18220 ecode2 = SWIG_AsVal_long(obj1, &val2);
18221 if (!SWIG_IsOK(ecode2)) {
18222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18223 }
18224 arg2 = static_cast< long >(val2);
18225 }
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 (arg1)->SetTimestamp(arg2);
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = SWIG_Py_Void();
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18240 PyObject *resultobj = 0;
18241 wxEvent *arg1 = (wxEvent *) 0 ;
18242 int result;
18243 void *argp1 = 0 ;
18244 int res1 = 0 ;
18245 PyObject *swig_obj[1] ;
18246
18247 if (!args) SWIG_fail;
18248 swig_obj[0] = args;
18249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18250 if (!SWIG_IsOK(res1)) {
18251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18252 }
18253 arg1 = reinterpret_cast< wxEvent * >(argp1);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = (int)((wxEvent const *)arg1)->GetId();
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_From_int(static_cast< int >(result));
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 int arg2 ;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 int val2 ;
18274 int ecode2 = 0 ;
18275 PyObject * obj0 = 0 ;
18276 PyObject * obj1 = 0 ;
18277 char * kwnames[] = {
18278 (char *) "self",(char *) "Id", NULL
18279 };
18280
18281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18283 if (!SWIG_IsOK(res1)) {
18284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18285 }
18286 arg1 = reinterpret_cast< wxEvent * >(argp1);
18287 ecode2 = SWIG_AsVal_int(obj1, &val2);
18288 if (!SWIG_IsOK(ecode2)) {
18289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18290 }
18291 arg2 = static_cast< int >(val2);
18292 {
18293 PyThreadState* __tstate = wxPyBeginAllowThreads();
18294 (arg1)->SetId(arg2);
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 resultobj = SWIG_Py_Void();
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18306 PyObject *resultobj = 0;
18307 wxEvent *arg1 = (wxEvent *) 0 ;
18308 bool result;
18309 void *argp1 = 0 ;
18310 int res1 = 0 ;
18311 PyObject *swig_obj[1] ;
18312
18313 if (!args) SWIG_fail;
18314 swig_obj[0] = args;
18315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18316 if (!SWIG_IsOK(res1)) {
18317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18318 }
18319 arg1 = reinterpret_cast< wxEvent * >(argp1);
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 {
18327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18328 }
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj = 0;
18337 wxEvent *arg1 = (wxEvent *) 0 ;
18338 bool arg2 = (bool) true ;
18339 void *argp1 = 0 ;
18340 int res1 = 0 ;
18341 bool val2 ;
18342 int ecode2 = 0 ;
18343 PyObject * obj0 = 0 ;
18344 PyObject * obj1 = 0 ;
18345 char * kwnames[] = {
18346 (char *) "self",(char *) "skip", NULL
18347 };
18348
18349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18351 if (!SWIG_IsOK(res1)) {
18352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18353 }
18354 arg1 = reinterpret_cast< wxEvent * >(argp1);
18355 if (obj1) {
18356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18357 if (!SWIG_IsOK(ecode2)) {
18358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18359 }
18360 arg2 = static_cast< bool >(val2);
18361 }
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 (arg1)->Skip(arg2);
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 resultobj = SWIG_Py_Void();
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18376 PyObject *resultobj = 0;
18377 wxEvent *arg1 = (wxEvent *) 0 ;
18378 bool result;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 PyObject *swig_obj[1] ;
18382
18383 if (!args) SWIG_fail;
18384 swig_obj[0] = args;
18385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18386 if (!SWIG_IsOK(res1)) {
18387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18388 }
18389 arg1 = reinterpret_cast< wxEvent * >(argp1);
18390 {
18391 PyThreadState* __tstate = wxPyBeginAllowThreads();
18392 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 {
18397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18398 }
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18406 PyObject *resultobj = 0;
18407 wxEvent *arg1 = (wxEvent *) 0 ;
18408 bool result;
18409 void *argp1 = 0 ;
18410 int res1 = 0 ;
18411 PyObject *swig_obj[1] ;
18412
18413 if (!args) SWIG_fail;
18414 swig_obj[0] = args;
18415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18416 if (!SWIG_IsOK(res1)) {
18417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18418 }
18419 arg1 = reinterpret_cast< wxEvent * >(argp1);
18420 {
18421 PyThreadState* __tstate = wxPyBeginAllowThreads();
18422 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18423 wxPyEndAllowThreads(__tstate);
18424 if (PyErr_Occurred()) SWIG_fail;
18425 }
18426 {
18427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18428 }
18429 return resultobj;
18430 fail:
18431 return NULL;
18432 }
18433
18434
18435 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18436 PyObject *resultobj = 0;
18437 wxEvent *arg1 = (wxEvent *) 0 ;
18438 int result;
18439 void *argp1 = 0 ;
18440 int res1 = 0 ;
18441 PyObject *swig_obj[1] ;
18442
18443 if (!args) SWIG_fail;
18444 swig_obj[0] = args;
18445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18446 if (!SWIG_IsOK(res1)) {
18447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18448 }
18449 arg1 = reinterpret_cast< wxEvent * >(argp1);
18450 {
18451 PyThreadState* __tstate = wxPyBeginAllowThreads();
18452 result = (int)(arg1)->StopPropagation();
18453 wxPyEndAllowThreads(__tstate);
18454 if (PyErr_Occurred()) SWIG_fail;
18455 }
18456 resultobj = SWIG_From_int(static_cast< int >(result));
18457 return resultobj;
18458 fail:
18459 return NULL;
18460 }
18461
18462
18463 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18464 PyObject *resultobj = 0;
18465 wxEvent *arg1 = (wxEvent *) 0 ;
18466 int arg2 ;
18467 void *argp1 = 0 ;
18468 int res1 = 0 ;
18469 int val2 ;
18470 int ecode2 = 0 ;
18471 PyObject * obj0 = 0 ;
18472 PyObject * obj1 = 0 ;
18473 char * kwnames[] = {
18474 (char *) "self",(char *) "propagationLevel", NULL
18475 };
18476
18477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18479 if (!SWIG_IsOK(res1)) {
18480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18481 }
18482 arg1 = reinterpret_cast< wxEvent * >(argp1);
18483 ecode2 = SWIG_AsVal_int(obj1, &val2);
18484 if (!SWIG_IsOK(ecode2)) {
18485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18486 }
18487 arg2 = static_cast< int >(val2);
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 (arg1)->ResumePropagation(arg2);
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = SWIG_Py_Void();
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18502 PyObject *resultobj = 0;
18503 wxEvent *arg1 = (wxEvent *) 0 ;
18504 wxEvent *result = 0 ;
18505 void *argp1 = 0 ;
18506 int res1 = 0 ;
18507 PyObject *swig_obj[1] ;
18508
18509 if (!args) SWIG_fail;
18510 swig_obj[0] = args;
18511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18512 if (!SWIG_IsOK(res1)) {
18513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18514 }
18515 arg1 = reinterpret_cast< wxEvent * >(argp1);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = (wxEvent *)(arg1)->Clone();
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18530 PyObject *obj;
18531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18532 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18533 return SWIG_Py_Void();
18534 }
18535
18536 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj = 0;
18538 wxEvent *arg1 = 0 ;
18539 wxPropagationDisabler *result = 0 ;
18540 void *argp1 = 0 ;
18541 int res1 = 0 ;
18542 PyObject * obj0 = 0 ;
18543 char * kwnames[] = {
18544 (char *) "event", NULL
18545 };
18546
18547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18548 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18551 }
18552 if (!argp1) {
18553 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18554 }
18555 arg1 = reinterpret_cast< wxEvent * >(argp1);
18556 {
18557 PyThreadState* __tstate = wxPyBeginAllowThreads();
18558 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18570 PyObject *resultobj = 0;
18571 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18572 void *argp1 = 0 ;
18573 int res1 = 0 ;
18574 PyObject *swig_obj[1] ;
18575
18576 if (!args) SWIG_fail;
18577 swig_obj[0] = args;
18578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18579 if (!SWIG_IsOK(res1)) {
18580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18581 }
18582 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 delete arg1;
18586
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_Py_Void();
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *obj;
18599 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18600 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18601 return SWIG_Py_Void();
18602 }
18603
18604 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18605 return SWIG_Python_InitShadowInstance(args);
18606 }
18607
18608 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj = 0;
18610 wxEvent *arg1 = 0 ;
18611 wxPropagateOnce *result = 0 ;
18612 void *argp1 = 0 ;
18613 int res1 = 0 ;
18614 PyObject * obj0 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "event", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18623 }
18624 if (!argp1) {
18625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18626 }
18627 arg1 = reinterpret_cast< wxEvent * >(argp1);
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18642 PyObject *resultobj = 0;
18643 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18644 void *argp1 = 0 ;
18645 int res1 = 0 ;
18646 PyObject *swig_obj[1] ;
18647
18648 if (!args) SWIG_fail;
18649 swig_obj[0] = args;
18650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18651 if (!SWIG_IsOK(res1)) {
18652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18653 }
18654 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 delete arg1;
18658
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 resultobj = SWIG_Py_Void();
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18670 PyObject *obj;
18671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18672 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18673 return SWIG_Py_Void();
18674 }
18675
18676 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18677 return SWIG_Python_InitShadowInstance(args);
18678 }
18679
18680 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = 0;
18682 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18683 int arg2 = (int) 0 ;
18684 wxCommandEvent *result = 0 ;
18685 int val1 ;
18686 int ecode1 = 0 ;
18687 int val2 ;
18688 int ecode2 = 0 ;
18689 PyObject * obj0 = 0 ;
18690 PyObject * obj1 = 0 ;
18691 char * kwnames[] = {
18692 (char *) "commandType",(char *) "winid", NULL
18693 };
18694
18695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18696 if (obj0) {
18697 ecode1 = SWIG_AsVal_int(obj0, &val1);
18698 if (!SWIG_IsOK(ecode1)) {
18699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18700 }
18701 arg1 = static_cast< wxEventType >(val1);
18702 }
18703 if (obj1) {
18704 ecode2 = SWIG_AsVal_int(obj1, &val2);
18705 if (!SWIG_IsOK(ecode2)) {
18706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18707 }
18708 arg2 = static_cast< int >(val2);
18709 }
18710 {
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18724 PyObject *resultobj = 0;
18725 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18726 int result;
18727 void *argp1 = 0 ;
18728 int res1 = 0 ;
18729 PyObject *swig_obj[1] ;
18730
18731 if (!args) SWIG_fail;
18732 swig_obj[0] = args;
18733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18734 if (!SWIG_IsOK(res1)) {
18735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18736 }
18737 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18738 {
18739 PyThreadState* __tstate = wxPyBeginAllowThreads();
18740 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18741 wxPyEndAllowThreads(__tstate);
18742 if (PyErr_Occurred()) SWIG_fail;
18743 }
18744 resultobj = SWIG_From_int(static_cast< int >(result));
18745 return resultobj;
18746 fail:
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18752 PyObject *resultobj = 0;
18753 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18754 wxString *arg2 = 0 ;
18755 void *argp1 = 0 ;
18756 int res1 = 0 ;
18757 bool temp2 = false ;
18758 PyObject * obj0 = 0 ;
18759 PyObject * obj1 = 0 ;
18760 char * kwnames[] = {
18761 (char *) "self",(char *) "s", NULL
18762 };
18763
18764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18766 if (!SWIG_IsOK(res1)) {
18767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18768 }
18769 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18770 {
18771 arg2 = wxString_in_helper(obj1);
18772 if (arg2 == NULL) SWIG_fail;
18773 temp2 = true;
18774 }
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 (arg1)->SetString((wxString const &)*arg2);
18778 wxPyEndAllowThreads(__tstate);
18779 if (PyErr_Occurred()) SWIG_fail;
18780 }
18781 resultobj = SWIG_Py_Void();
18782 {
18783 if (temp2)
18784 delete arg2;
18785 }
18786 return resultobj;
18787 fail:
18788 {
18789 if (temp2)
18790 delete arg2;
18791 }
18792 return NULL;
18793 }
18794
18795
18796 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18797 PyObject *resultobj = 0;
18798 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18799 wxString result;
18800 void *argp1 = 0 ;
18801 int res1 = 0 ;
18802 PyObject *swig_obj[1] ;
18803
18804 if (!args) SWIG_fail;
18805 swig_obj[0] = args;
18806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18807 if (!SWIG_IsOK(res1)) {
18808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18809 }
18810 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18811 {
18812 PyThreadState* __tstate = wxPyBeginAllowThreads();
18813 result = ((wxCommandEvent const *)arg1)->GetString();
18814 wxPyEndAllowThreads(__tstate);
18815 if (PyErr_Occurred()) SWIG_fail;
18816 }
18817 {
18818 #if wxUSE_UNICODE
18819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18820 #else
18821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18822 #endif
18823 }
18824 return resultobj;
18825 fail:
18826 return NULL;
18827 }
18828
18829
18830 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18831 PyObject *resultobj = 0;
18832 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18833 bool result;
18834 void *argp1 = 0 ;
18835 int res1 = 0 ;
18836 PyObject *swig_obj[1] ;
18837
18838 if (!args) SWIG_fail;
18839 swig_obj[0] = args;
18840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18841 if (!SWIG_IsOK(res1)) {
18842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18843 }
18844 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18845 {
18846 PyThreadState* __tstate = wxPyBeginAllowThreads();
18847 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18848 wxPyEndAllowThreads(__tstate);
18849 if (PyErr_Occurred()) SWIG_fail;
18850 }
18851 {
18852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18853 }
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18861 PyObject *resultobj = 0;
18862 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18863 bool result;
18864 void *argp1 = 0 ;
18865 int res1 = 0 ;
18866 PyObject *swig_obj[1] ;
18867
18868 if (!args) SWIG_fail;
18869 swig_obj[0] = args;
18870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18871 if (!SWIG_IsOK(res1)) {
18872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18873 }
18874 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18875 {
18876 PyThreadState* __tstate = wxPyBeginAllowThreads();
18877 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18878 wxPyEndAllowThreads(__tstate);
18879 if (PyErr_Occurred()) SWIG_fail;
18880 }
18881 {
18882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18883 }
18884 return resultobj;
18885 fail:
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18891 PyObject *resultobj = 0;
18892 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18893 long arg2 ;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 long val2 ;
18897 int ecode2 = 0 ;
18898 PyObject * obj0 = 0 ;
18899 PyObject * obj1 = 0 ;
18900 char * kwnames[] = {
18901 (char *) "self",(char *) "extraLong", NULL
18902 };
18903
18904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18906 if (!SWIG_IsOK(res1)) {
18907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18908 }
18909 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18910 ecode2 = SWIG_AsVal_long(obj1, &val2);
18911 if (!SWIG_IsOK(ecode2)) {
18912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18913 }
18914 arg2 = static_cast< long >(val2);
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 (arg1)->SetExtraLong(arg2);
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_Py_Void();
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18929 PyObject *resultobj = 0;
18930 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18931 long result;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 PyObject *swig_obj[1] ;
18935
18936 if (!args) SWIG_fail;
18937 swig_obj[0] = args;
18938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18939 if (!SWIG_IsOK(res1)) {
18940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18941 }
18942 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18943 {
18944 PyThreadState* __tstate = wxPyBeginAllowThreads();
18945 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18946 wxPyEndAllowThreads(__tstate);
18947 if (PyErr_Occurred()) SWIG_fail;
18948 }
18949 resultobj = SWIG_From_long(static_cast< long >(result));
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18957 PyObject *resultobj = 0;
18958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18959 int arg2 ;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 int val2 ;
18963 int ecode2 = 0 ;
18964 PyObject * obj0 = 0 ;
18965 PyObject * obj1 = 0 ;
18966 char * kwnames[] = {
18967 (char *) "self",(char *) "i", NULL
18968 };
18969
18970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18972 if (!SWIG_IsOK(res1)) {
18973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18974 }
18975 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18976 ecode2 = SWIG_AsVal_int(obj1, &val2);
18977 if (!SWIG_IsOK(ecode2)) {
18978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18979 }
18980 arg2 = static_cast< int >(val2);
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 (arg1)->SetInt(arg2);
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 resultobj = SWIG_Py_Void();
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18995 PyObject *resultobj = 0;
18996 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18997 long result;
18998 void *argp1 = 0 ;
18999 int res1 = 0 ;
19000 PyObject *swig_obj[1] ;
19001
19002 if (!args) SWIG_fail;
19003 swig_obj[0] = args;
19004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19005 if (!SWIG_IsOK(res1)) {
19006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19007 }
19008 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 resultobj = SWIG_From_long(static_cast< long >(result));
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 PyObject *result = 0 ;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = result;
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj = 0;
19052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19053 PyObject *arg2 = (PyObject *) 0 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 PyObject * obj0 = 0 ;
19057 PyObject * obj1 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "clientData", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19066 }
19067 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19068 arg2 = obj1;
19069 {
19070 PyThreadState* __tstate = wxPyBeginAllowThreads();
19071 wxCommandEvent_SetClientData(arg1,arg2);
19072 wxPyEndAllowThreads(__tstate);
19073 if (PyErr_Occurred()) SWIG_fail;
19074 }
19075 resultobj = SWIG_Py_Void();
19076 return resultobj;
19077 fail:
19078 return NULL;
19079 }
19080
19081
19082 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19083 PyObject *resultobj = 0;
19084 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19085 wxEvent *result = 0 ;
19086 void *argp1 = 0 ;
19087 int res1 = 0 ;
19088 PyObject *swig_obj[1] ;
19089
19090 if (!args) SWIG_fail;
19091 swig_obj[0] = args;
19092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19093 if (!SWIG_IsOK(res1)) {
19094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19095 }
19096 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19097 {
19098 PyThreadState* __tstate = wxPyBeginAllowThreads();
19099 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19100 wxPyEndAllowThreads(__tstate);
19101 if (PyErr_Occurred()) SWIG_fail;
19102 }
19103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19104 return resultobj;
19105 fail:
19106 return NULL;
19107 }
19108
19109
19110 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19111 PyObject *obj;
19112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19113 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19114 return SWIG_Py_Void();
19115 }
19116
19117 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19118 return SWIG_Python_InitShadowInstance(args);
19119 }
19120
19121 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj = 0;
19123 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19124 int arg2 = (int) 0 ;
19125 wxNotifyEvent *result = 0 ;
19126 int val1 ;
19127 int ecode1 = 0 ;
19128 int val2 ;
19129 int ecode2 = 0 ;
19130 PyObject * obj0 = 0 ;
19131 PyObject * obj1 = 0 ;
19132 char * kwnames[] = {
19133 (char *) "commandType",(char *) "winid", NULL
19134 };
19135
19136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19137 if (obj0) {
19138 ecode1 = SWIG_AsVal_int(obj0, &val1);
19139 if (!SWIG_IsOK(ecode1)) {
19140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19141 }
19142 arg1 = static_cast< wxEventType >(val1);
19143 }
19144 if (obj1) {
19145 ecode2 = SWIG_AsVal_int(obj1, &val2);
19146 if (!SWIG_IsOK(ecode2)) {
19147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19148 }
19149 arg2 = static_cast< int >(val2);
19150 }
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19165 PyObject *resultobj = 0;
19166 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 PyObject *swig_obj[1] ;
19170
19171 if (!args) SWIG_fail;
19172 swig_obj[0] = args;
19173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19174 if (!SWIG_IsOK(res1)) {
19175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19176 }
19177 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 (arg1)->Veto();
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 resultobj = SWIG_Py_Void();
19185 return resultobj;
19186 fail:
19187 return NULL;
19188 }
19189
19190
19191 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19192 PyObject *resultobj = 0;
19193 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19194 void *argp1 = 0 ;
19195 int res1 = 0 ;
19196 PyObject *swig_obj[1] ;
19197
19198 if (!args) SWIG_fail;
19199 swig_obj[0] = args;
19200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19201 if (!SWIG_IsOK(res1)) {
19202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19203 }
19204 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19205 {
19206 PyThreadState* __tstate = wxPyBeginAllowThreads();
19207 (arg1)->Allow();
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 resultobj = SWIG_Py_Void();
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19219 PyObject *resultobj = 0;
19220 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19221 bool result;
19222 void *argp1 = 0 ;
19223 int res1 = 0 ;
19224 PyObject *swig_obj[1] ;
19225
19226 if (!args) SWIG_fail;
19227 swig_obj[0] = args;
19228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19231 }
19232 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (bool)(arg1)->IsAllowed();
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 {
19240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19241 }
19242 return resultobj;
19243 fail:
19244 return NULL;
19245 }
19246
19247
19248 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19249 PyObject *obj;
19250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19251 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19252 return SWIG_Py_Void();
19253 }
19254
19255 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19256 return SWIG_Python_InitShadowInstance(args);
19257 }
19258
19259 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj = 0;
19261 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19262 int arg2 = (int) 0 ;
19263 int arg3 = (int) 0 ;
19264 int arg4 = (int) 0 ;
19265 wxScrollEvent *result = 0 ;
19266 int val1 ;
19267 int ecode1 = 0 ;
19268 int val2 ;
19269 int ecode2 = 0 ;
19270 int val3 ;
19271 int ecode3 = 0 ;
19272 int val4 ;
19273 int ecode4 = 0 ;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 PyObject * obj2 = 0 ;
19277 PyObject * obj3 = 0 ;
19278 char * kwnames[] = {
19279 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19280 };
19281
19282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19283 if (obj0) {
19284 ecode1 = SWIG_AsVal_int(obj0, &val1);
19285 if (!SWIG_IsOK(ecode1)) {
19286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19287 }
19288 arg1 = static_cast< wxEventType >(val1);
19289 }
19290 if (obj1) {
19291 ecode2 = SWIG_AsVal_int(obj1, &val2);
19292 if (!SWIG_IsOK(ecode2)) {
19293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19294 }
19295 arg2 = static_cast< int >(val2);
19296 }
19297 if (obj2) {
19298 ecode3 = SWIG_AsVal_int(obj2, &val3);
19299 if (!SWIG_IsOK(ecode3)) {
19300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19301 }
19302 arg3 = static_cast< int >(val3);
19303 }
19304 if (obj3) {
19305 ecode4 = SWIG_AsVal_int(obj3, &val4);
19306 if (!SWIG_IsOK(ecode4)) {
19307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19308 }
19309 arg4 = static_cast< int >(val4);
19310 }
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19325 PyObject *resultobj = 0;
19326 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19327 int result;
19328 void *argp1 = 0 ;
19329 int res1 = 0 ;
19330 PyObject *swig_obj[1] ;
19331
19332 if (!args) SWIG_fail;
19333 swig_obj[0] = args;
19334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19335 if (!SWIG_IsOK(res1)) {
19336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19337 }
19338 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19342 wxPyEndAllowThreads(__tstate);
19343 if (PyErr_Occurred()) SWIG_fail;
19344 }
19345 resultobj = SWIG_From_int(static_cast< int >(result));
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19353 PyObject *resultobj = 0;
19354 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19355 int result;
19356 void *argp1 = 0 ;
19357 int res1 = 0 ;
19358 PyObject *swig_obj[1] ;
19359
19360 if (!args) SWIG_fail;
19361 swig_obj[0] = args;
19362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19363 if (!SWIG_IsOK(res1)) {
19364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19365 }
19366 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19367 {
19368 PyThreadState* __tstate = wxPyBeginAllowThreads();
19369 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19370 wxPyEndAllowThreads(__tstate);
19371 if (PyErr_Occurred()) SWIG_fail;
19372 }
19373 resultobj = SWIG_From_int(static_cast< int >(result));
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19381 PyObject *resultobj = 0;
19382 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19383 int arg2 ;
19384 void *argp1 = 0 ;
19385 int res1 = 0 ;
19386 int val2 ;
19387 int ecode2 = 0 ;
19388 PyObject * obj0 = 0 ;
19389 PyObject * obj1 = 0 ;
19390 char * kwnames[] = {
19391 (char *) "self",(char *) "orient", NULL
19392 };
19393
19394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19396 if (!SWIG_IsOK(res1)) {
19397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19398 }
19399 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19400 ecode2 = SWIG_AsVal_int(obj1, &val2);
19401 if (!SWIG_IsOK(ecode2)) {
19402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19403 }
19404 arg2 = static_cast< int >(val2);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 (arg1)->SetOrientation(arg2);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_Py_Void();
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19421 int arg2 ;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 int val2 ;
19425 int ecode2 = 0 ;
19426 PyObject * obj0 = 0 ;
19427 PyObject * obj1 = 0 ;
19428 char * kwnames[] = {
19429 (char *) "self",(char *) "pos", NULL
19430 };
19431
19432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19434 if (!SWIG_IsOK(res1)) {
19435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19436 }
19437 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19438 ecode2 = SWIG_AsVal_int(obj1, &val2);
19439 if (!SWIG_IsOK(ecode2)) {
19440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19441 }
19442 arg2 = static_cast< int >(val2);
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 (arg1)->SetPosition(arg2);
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 resultobj = SWIG_Py_Void();
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19457 PyObject *obj;
19458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19459 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19460 return SWIG_Py_Void();
19461 }
19462
19463 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19464 return SWIG_Python_InitShadowInstance(args);
19465 }
19466
19467 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj = 0;
19469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19470 int arg2 = (int) 0 ;
19471 int arg3 = (int) 0 ;
19472 wxScrollWinEvent *result = 0 ;
19473 int val1 ;
19474 int ecode1 = 0 ;
19475 int val2 ;
19476 int ecode2 = 0 ;
19477 int val3 ;
19478 int ecode3 = 0 ;
19479 PyObject * obj0 = 0 ;
19480 PyObject * obj1 = 0 ;
19481 PyObject * obj2 = 0 ;
19482 char * kwnames[] = {
19483 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19484 };
19485
19486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19487 if (obj0) {
19488 ecode1 = SWIG_AsVal_int(obj0, &val1);
19489 if (!SWIG_IsOK(ecode1)) {
19490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19491 }
19492 arg1 = static_cast< wxEventType >(val1);
19493 }
19494 if (obj1) {
19495 ecode2 = SWIG_AsVal_int(obj1, &val2);
19496 if (!SWIG_IsOK(ecode2)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19498 }
19499 arg2 = static_cast< int >(val2);
19500 }
19501 if (obj2) {
19502 ecode3 = SWIG_AsVal_int(obj2, &val3);
19503 if (!SWIG_IsOK(ecode3)) {
19504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19505 }
19506 arg3 = static_cast< int >(val3);
19507 }
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19511 wxPyEndAllowThreads(__tstate);
19512 if (PyErr_Occurred()) SWIG_fail;
19513 }
19514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19515 return resultobj;
19516 fail:
19517 return NULL;
19518 }
19519
19520
19521 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19522 PyObject *resultobj = 0;
19523 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19524 int result;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 PyObject *swig_obj[1] ;
19528
19529 if (!args) SWIG_fail;
19530 swig_obj[0] = args;
19531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19532 if (!SWIG_IsOK(res1)) {
19533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19534 }
19535 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 resultobj = SWIG_From_int(static_cast< int >(result));
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19550 PyObject *resultobj = 0;
19551 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19552 int result;
19553 void *argp1 = 0 ;
19554 int res1 = 0 ;
19555 PyObject *swig_obj[1] ;
19556
19557 if (!args) SWIG_fail;
19558 swig_obj[0] = args;
19559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19560 if (!SWIG_IsOK(res1)) {
19561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19562 }
19563 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 resultobj = SWIG_From_int(static_cast< int >(result));
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj = 0;
19579 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19580 int arg2 ;
19581 void *argp1 = 0 ;
19582 int res1 = 0 ;
19583 int val2 ;
19584 int ecode2 = 0 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 char * kwnames[] = {
19588 (char *) "self",(char *) "orient", NULL
19589 };
19590
19591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19593 if (!SWIG_IsOK(res1)) {
19594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19595 }
19596 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19597 ecode2 = SWIG_AsVal_int(obj1, &val2);
19598 if (!SWIG_IsOK(ecode2)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19600 }
19601 arg2 = static_cast< int >(val2);
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 (arg1)->SetOrientation(arg2);
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 resultobj = SWIG_Py_Void();
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19616 PyObject *resultobj = 0;
19617 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19618 int arg2 ;
19619 void *argp1 = 0 ;
19620 int res1 = 0 ;
19621 int val2 ;
19622 int ecode2 = 0 ;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 char * kwnames[] = {
19626 (char *) "self",(char *) "pos", NULL
19627 };
19628
19629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19631 if (!SWIG_IsOK(res1)) {
19632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19633 }
19634 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19635 ecode2 = SWIG_AsVal_int(obj1, &val2);
19636 if (!SWIG_IsOK(ecode2)) {
19637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19638 }
19639 arg2 = static_cast< int >(val2);
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 (arg1)->SetPosition(arg2);
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_Py_Void();
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654 PyObject *obj;
19655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19656 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19657 return SWIG_Py_Void();
19658 }
19659
19660 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19661 return SWIG_Python_InitShadowInstance(args);
19662 }
19663
19664 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj = 0;
19666 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19667 wxMouseEvent *result = 0 ;
19668 int val1 ;
19669 int ecode1 = 0 ;
19670 PyObject * obj0 = 0 ;
19671 char * kwnames[] = {
19672 (char *) "mouseType", NULL
19673 };
19674
19675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19676 if (obj0) {
19677 ecode1 = SWIG_AsVal_int(obj0, &val1);
19678 if (!SWIG_IsOK(ecode1)) {
19679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19680 }
19681 arg1 = static_cast< wxEventType >(val1);
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19686 wxPyEndAllowThreads(__tstate);
19687 if (PyErr_Occurred()) SWIG_fail;
19688 }
19689 {
19690 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19691 }
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19701 bool result;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19711 }
19712 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 {
19720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19721 }
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj = 0;
19730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19731 int arg2 = (int) wxMOUSE_BTN_ANY ;
19732 bool result;
19733 void *argp1 = 0 ;
19734 int res1 = 0 ;
19735 int val2 ;
19736 int ecode2 = 0 ;
19737 PyObject * obj0 = 0 ;
19738 PyObject * obj1 = 0 ;
19739 char * kwnames[] = {
19740 (char *) "self",(char *) "but", NULL
19741 };
19742
19743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19745 if (!SWIG_IsOK(res1)) {
19746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19747 }
19748 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19749 if (obj1) {
19750 ecode2 = SWIG_AsVal_int(obj1, &val2);
19751 if (!SWIG_IsOK(ecode2)) {
19752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19753 }
19754 arg2 = static_cast< int >(val2);
19755 }
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 {
19763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19764 }
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19772 PyObject *resultobj = 0;
19773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19774 int arg2 = (int) wxMOUSE_BTN_ANY ;
19775 bool result;
19776 void *argp1 = 0 ;
19777 int res1 = 0 ;
19778 int val2 ;
19779 int ecode2 = 0 ;
19780 PyObject * obj0 = 0 ;
19781 PyObject * obj1 = 0 ;
19782 char * kwnames[] = {
19783 (char *) "self",(char *) "but", NULL
19784 };
19785
19786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19788 if (!SWIG_IsOK(res1)) {
19789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19790 }
19791 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19792 if (obj1) {
19793 ecode2 = SWIG_AsVal_int(obj1, &val2);
19794 if (!SWIG_IsOK(ecode2)) {
19795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19796 }
19797 arg2 = static_cast< int >(val2);
19798 }
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj = 0;
19816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19817 int arg2 = (int) wxMOUSE_BTN_ANY ;
19818 bool result;
19819 void *argp1 = 0 ;
19820 int res1 = 0 ;
19821 int val2 ;
19822 int ecode2 = 0 ;
19823 PyObject * obj0 = 0 ;
19824 PyObject * obj1 = 0 ;
19825 char * kwnames[] = {
19826 (char *) "self",(char *) "but", NULL
19827 };
19828
19829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19831 if (!SWIG_IsOK(res1)) {
19832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19833 }
19834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19835 if (obj1) {
19836 ecode2 = SWIG_AsVal_int(obj1, &val2);
19837 if (!SWIG_IsOK(ecode2)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19839 }
19840 arg2 = static_cast< int >(val2);
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19858 PyObject *resultobj = 0;
19859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19860 int arg2 ;
19861 bool result;
19862 void *argp1 = 0 ;
19863 int res1 = 0 ;
19864 int val2 ;
19865 int ecode2 = 0 ;
19866 PyObject * obj0 = 0 ;
19867 PyObject * obj1 = 0 ;
19868 char * kwnames[] = {
19869 (char *) "self",(char *) "button", NULL
19870 };
19871
19872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19874 if (!SWIG_IsOK(res1)) {
19875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19876 }
19877 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19878 ecode2 = SWIG_AsVal_int(obj1, &val2);
19879 if (!SWIG_IsOK(ecode2)) {
19880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19881 }
19882 arg2 = static_cast< int >(val2);
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 {
19890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19891 }
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj = 0;
19900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19901 int arg2 ;
19902 bool result;
19903 void *argp1 = 0 ;
19904 int res1 = 0 ;
19905 int val2 ;
19906 int ecode2 = 0 ;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 char * kwnames[] = {
19910 (char *) "self",(char *) "but", NULL
19911 };
19912
19913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19915 if (!SWIG_IsOK(res1)) {
19916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19917 }
19918 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19919 ecode2 = SWIG_AsVal_int(obj1, &val2);
19920 if (!SWIG_IsOK(ecode2)) {
19921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19922 }
19923 arg2 = static_cast< int >(val2);
19924 {
19925 PyThreadState* __tstate = wxPyBeginAllowThreads();
19926 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19927 wxPyEndAllowThreads(__tstate);
19928 if (PyErr_Occurred()) SWIG_fail;
19929 }
19930 {
19931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19932 }
19933 return resultobj;
19934 fail:
19935 return NULL;
19936 }
19937
19938
19939 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19940 PyObject *resultobj = 0;
19941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19942 int result;
19943 void *argp1 = 0 ;
19944 int res1 = 0 ;
19945 PyObject *swig_obj[1] ;
19946
19947 if (!args) SWIG_fail;
19948 swig_obj[0] = args;
19949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19950 if (!SWIG_IsOK(res1)) {
19951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19952 }
19953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19957 wxPyEndAllowThreads(__tstate);
19958 if (PyErr_Occurred()) SWIG_fail;
19959 }
19960 resultobj = SWIG_From_int(static_cast< int >(result));
19961 return resultobj;
19962 fail:
19963 return NULL;
19964 }
19965
19966
19967 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19968 PyObject *resultobj = 0;
19969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19970 bool result;
19971 void *argp1 = 0 ;
19972 int res1 = 0 ;
19973 PyObject *swig_obj[1] ;
19974
19975 if (!args) SWIG_fail;
19976 swig_obj[0] = args;
19977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19978 if (!SWIG_IsOK(res1)) {
19979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19980 }
19981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19985 wxPyEndAllowThreads(__tstate);
19986 if (PyErr_Occurred()) SWIG_fail;
19987 }
19988 {
19989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19990 }
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19998 PyObject *resultobj = 0;
19999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20000 bool result;
20001 void *argp1 = 0 ;
20002 int res1 = 0 ;
20003 PyObject *swig_obj[1] ;
20004
20005 if (!args) SWIG_fail;
20006 swig_obj[0] = args;
20007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20008 if (!SWIG_IsOK(res1)) {
20009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20010 }
20011 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 {
20019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20020 }
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20028 PyObject *resultobj = 0;
20029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20030 bool result;
20031 void *argp1 = 0 ;
20032 int res1 = 0 ;
20033 PyObject *swig_obj[1] ;
20034
20035 if (!args) SWIG_fail;
20036 swig_obj[0] = args;
20037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 {
20049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20050 }
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *resultobj = 0;
20059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20060 bool result;
20061 void *argp1 = 0 ;
20062 int res1 = 0 ;
20063 PyObject *swig_obj[1] ;
20064
20065 if (!args) SWIG_fail;
20066 swig_obj[0] = args;
20067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20068 if (!SWIG_IsOK(res1)) {
20069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20070 }
20071 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20080 }
20081 return resultobj;
20082 fail:
20083 return NULL;
20084 }
20085
20086
20087 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20088 PyObject *resultobj = 0;
20089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20090 bool result;
20091 void *argp1 = 0 ;
20092 int res1 = 0 ;
20093 PyObject *swig_obj[1] ;
20094
20095 if (!args) SWIG_fail;
20096 swig_obj[0] = args;
20097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20098 if (!SWIG_IsOK(res1)) {
20099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20100 }
20101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20118 PyObject *resultobj = 0;
20119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20120 bool result;
20121 void *argp1 = 0 ;
20122 int res1 = 0 ;
20123 PyObject *swig_obj[1] ;
20124
20125 if (!args) SWIG_fail;
20126 swig_obj[0] = args;
20127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20128 if (!SWIG_IsOK(res1)) {
20129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20130 }
20131 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 {
20139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20140 }
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *resultobj = 0;
20149 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20150 bool result;
20151 void *argp1 = 0 ;
20152 int res1 = 0 ;
20153 PyObject *swig_obj[1] ;
20154
20155 if (!args) SWIG_fail;
20156 swig_obj[0] = args;
20157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20158 if (!SWIG_IsOK(res1)) {
20159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20160 }
20161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 {
20169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20170 }
20171 return resultobj;
20172 fail:
20173 return NULL;
20174 }
20175
20176
20177 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20178 PyObject *resultobj = 0;
20179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20180 bool result;
20181 void *argp1 = 0 ;
20182 int res1 = 0 ;
20183 PyObject *swig_obj[1] ;
20184
20185 if (!args) SWIG_fail;
20186 swig_obj[0] = args;
20187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20188 if (!SWIG_IsOK(res1)) {
20189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20190 }
20191 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 {
20199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20200 }
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20208 PyObject *resultobj = 0;
20209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20210 bool result;
20211 void *argp1 = 0 ;
20212 int res1 = 0 ;
20213 PyObject *swig_obj[1] ;
20214
20215 if (!args) SWIG_fail;
20216 swig_obj[0] = args;
20217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20218 if (!SWIG_IsOK(res1)) {
20219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20220 }
20221 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 {
20229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20238 PyObject *resultobj = 0;
20239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20240 bool result;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 PyObject *swig_obj[1] ;
20244
20245 if (!args) SWIG_fail;
20246 swig_obj[0] = args;
20247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20248 if (!SWIG_IsOK(res1)) {
20249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20250 }
20251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20252 {
20253 PyThreadState* __tstate = wxPyBeginAllowThreads();
20254 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 {
20259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20260 }
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 PyObject *resultobj = 0;
20269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20270 bool result;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 PyObject *swig_obj[1] ;
20274
20275 if (!args) SWIG_fail;
20276 swig_obj[0] = args;
20277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20280 }
20281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 {
20289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20290 }
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 PyObject *resultobj = 0;
20299 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20300 bool result;
20301 void *argp1 = 0 ;
20302 int res1 = 0 ;
20303 PyObject *swig_obj[1] ;
20304
20305 if (!args) SWIG_fail;
20306 swig_obj[0] = args;
20307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20308 if (!SWIG_IsOK(res1)) {
20309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20310 }
20311 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 {
20319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20320 }
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *resultobj = 0;
20329 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20330 bool result;
20331 void *argp1 = 0 ;
20332 int res1 = 0 ;
20333 PyObject *swig_obj[1] ;
20334
20335 if (!args) SWIG_fail;
20336 swig_obj[0] = args;
20337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20338 if (!SWIG_IsOK(res1)) {
20339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20340 }
20341 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20342 {
20343 PyThreadState* __tstate = wxPyBeginAllowThreads();
20344 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 {
20349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20350 }
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 PyObject *resultobj = 0;
20359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20360 bool result;
20361 void *argp1 = 0 ;
20362 int res1 = 0 ;
20363 PyObject *swig_obj[1] ;
20364
20365 if (!args) SWIG_fail;
20366 swig_obj[0] = args;
20367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20368 if (!SWIG_IsOK(res1)) {
20369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20370 }
20371 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20372 {
20373 PyThreadState* __tstate = wxPyBeginAllowThreads();
20374 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 {
20379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20380 }
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20388 PyObject *resultobj = 0;
20389 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20390 bool result;
20391 void *argp1 = 0 ;
20392 int res1 = 0 ;
20393 PyObject *swig_obj[1] ;
20394
20395 if (!args) SWIG_fail;
20396 swig_obj[0] = args;
20397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20398 if (!SWIG_IsOK(res1)) {
20399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20400 }
20401 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 result = (bool)(arg1)->LeftIsDown();
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 {
20409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20410 }
20411 return resultobj;
20412 fail:
20413 return NULL;
20414 }
20415
20416
20417 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20418 PyObject *resultobj = 0;
20419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20420 bool result;
20421 void *argp1 = 0 ;
20422 int res1 = 0 ;
20423 PyObject *swig_obj[1] ;
20424
20425 if (!args) SWIG_fail;
20426 swig_obj[0] = args;
20427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20428 if (!SWIG_IsOK(res1)) {
20429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20430 }
20431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20432 {
20433 PyThreadState* __tstate = wxPyBeginAllowThreads();
20434 result = (bool)(arg1)->MiddleIsDown();
20435 wxPyEndAllowThreads(__tstate);
20436 if (PyErr_Occurred()) SWIG_fail;
20437 }
20438 {
20439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20440 }
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *resultobj = 0;
20449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20450 bool result;
20451 void *argp1 = 0 ;
20452 int res1 = 0 ;
20453 PyObject *swig_obj[1] ;
20454
20455 if (!args) SWIG_fail;
20456 swig_obj[0] = args;
20457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20458 if (!SWIG_IsOK(res1)) {
20459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20460 }
20461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20462 {
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = (bool)(arg1)->RightIsDown();
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 {
20469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20470 }
20471 return resultobj;
20472 fail:
20473 return NULL;
20474 }
20475
20476
20477 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20478 PyObject *resultobj = 0;
20479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20480 bool result;
20481 void *argp1 = 0 ;
20482 int res1 = 0 ;
20483 PyObject *swig_obj[1] ;
20484
20485 if (!args) SWIG_fail;
20486 swig_obj[0] = args;
20487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20488 if (!SWIG_IsOK(res1)) {
20489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20490 }
20491 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20492 {
20493 PyThreadState* __tstate = wxPyBeginAllowThreads();
20494 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20495 wxPyEndAllowThreads(__tstate);
20496 if (PyErr_Occurred()) SWIG_fail;
20497 }
20498 {
20499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20500 }
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20508 PyObject *resultobj = 0;
20509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20510 bool result;
20511 void *argp1 = 0 ;
20512 int res1 = 0 ;
20513 PyObject *swig_obj[1] ;
20514
20515 if (!args) SWIG_fail;
20516 swig_obj[0] = args;
20517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20518 if (!SWIG_IsOK(res1)) {
20519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20520 }
20521 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 {
20529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20530 }
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20540 bool result;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 PyObject *swig_obj[1] ;
20544
20545 if (!args) SWIG_fail;
20546 swig_obj[0] = args;
20547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20548 if (!SWIG_IsOK(res1)) {
20549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20550 }
20551 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 {
20559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20560 }
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20568 PyObject *resultobj = 0;
20569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20570 bool result;
20571 void *argp1 = 0 ;
20572 int res1 = 0 ;
20573 PyObject *swig_obj[1] ;
20574
20575 if (!args) SWIG_fail;
20576 swig_obj[0] = args;
20577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20578 if (!SWIG_IsOK(res1)) {
20579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20580 }
20581 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20585 wxPyEndAllowThreads(__tstate);
20586 if (PyErr_Occurred()) SWIG_fail;
20587 }
20588 {
20589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20590 }
20591 return resultobj;
20592 fail:
20593 return NULL;
20594 }
20595
20596
20597 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20598 PyObject *resultobj = 0;
20599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20600 wxPoint result;
20601 void *argp1 = 0 ;
20602 int res1 = 0 ;
20603 PyObject *swig_obj[1] ;
20604
20605 if (!args) SWIG_fail;
20606 swig_obj[0] = args;
20607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20608 if (!SWIG_IsOK(res1)) {
20609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20610 }
20611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20612 {
20613 PyThreadState* __tstate = wxPyBeginAllowThreads();
20614 result = (arg1)->GetPosition();
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 long *arg2 = (long *) 0 ;
20629 long *arg3 = (long *) 0 ;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 long temp2 ;
20633 int res2 = SWIG_TMPOBJ ;
20634 long temp3 ;
20635 int res3 = SWIG_TMPOBJ ;
20636 PyObject *swig_obj[1] ;
20637
20638 arg2 = &temp2;
20639 arg3 = &temp3;
20640 if (!args) SWIG_fail;
20641 swig_obj[0] = args;
20642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20643 if (!SWIG_IsOK(res1)) {
20644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20645 }
20646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 (arg1)->GetPosition(arg2,arg3);
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 resultobj = SWIG_Py_Void();
20654 if (SWIG_IsTmpObj(res2)) {
20655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20656 } else {
20657 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20659 }
20660 if (SWIG_IsTmpObj(res3)) {
20661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20662 } else {
20663 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20665 }
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20673 PyObject *resultobj = 0;
20674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20675 wxDC *arg2 = 0 ;
20676 wxPoint result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 void *argp2 = 0 ;
20680 int res2 = 0 ;
20681 PyObject * obj0 = 0 ;
20682 PyObject * obj1 = 0 ;
20683 char * kwnames[] = {
20684 (char *) "self",(char *) "dc", NULL
20685 };
20686
20687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20689 if (!SWIG_IsOK(res1)) {
20690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20691 }
20692 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20694 if (!SWIG_IsOK(res2)) {
20695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20696 }
20697 if (!argp2) {
20698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20699 }
20700 arg2 = reinterpret_cast< wxDC * >(argp2);
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20715 PyObject *resultobj = 0;
20716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20717 int result;
20718 void *argp1 = 0 ;
20719 int res1 = 0 ;
20720 PyObject *swig_obj[1] ;
20721
20722 if (!args) SWIG_fail;
20723 swig_obj[0] = args;
20724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20725 if (!SWIG_IsOK(res1)) {
20726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20727 }
20728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (int)((wxMouseEvent const *)arg1)->GetX();
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 resultobj = SWIG_From_int(static_cast< int >(result));
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20743 PyObject *resultobj = 0;
20744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20745 int result;
20746 void *argp1 = 0 ;
20747 int res1 = 0 ;
20748 PyObject *swig_obj[1] ;
20749
20750 if (!args) SWIG_fail;
20751 swig_obj[0] = args;
20752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20755 }
20756 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = (int)((wxMouseEvent const *)arg1)->GetY();
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_From_int(static_cast< int >(result));
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20771 PyObject *resultobj = 0;
20772 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20773 int result;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 PyObject *swig_obj[1] ;
20777
20778 if (!args) SWIG_fail;
20779 swig_obj[0] = args;
20780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20783 }
20784 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 resultobj = SWIG_From_int(static_cast< int >(result));
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20799 PyObject *resultobj = 0;
20800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20801 int result;
20802 void *argp1 = 0 ;
20803 int res1 = 0 ;
20804 PyObject *swig_obj[1] ;
20805
20806 if (!args) SWIG_fail;
20807 swig_obj[0] = args;
20808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20809 if (!SWIG_IsOK(res1)) {
20810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20811 }
20812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_From_int(static_cast< int >(result));
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *resultobj = 0;
20828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20829 int result;
20830 void *argp1 = 0 ;
20831 int res1 = 0 ;
20832 PyObject *swig_obj[1] ;
20833
20834 if (!args) SWIG_fail;
20835 swig_obj[0] = args;
20836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20837 if (!SWIG_IsOK(res1)) {
20838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20839 }
20840 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_From_int(static_cast< int >(result));
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20857 bool result;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 PyObject *swig_obj[1] ;
20861
20862 if (!args) SWIG_fail;
20863 swig_obj[0] = args;
20864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 {
20876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20877 }
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20885 PyObject *resultobj = 0;
20886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20887 int arg2 ;
20888 void *argp1 = 0 ;
20889 int res1 = 0 ;
20890 int val2 ;
20891 int ecode2 = 0 ;
20892 PyObject *swig_obj[2] ;
20893
20894 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20896 if (!SWIG_IsOK(res1)) {
20897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20898 }
20899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20900 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20901 if (!SWIG_IsOK(ecode2)) {
20902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20903 }
20904 arg2 = static_cast< int >(val2);
20905 if (arg1) (arg1)->m_x = arg2;
20906
20907 resultobj = SWIG_Py_Void();
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 int result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 result = (int) ((arg1)->m_x);
20930 resultobj = SWIG_From_int(static_cast< int >(result));
20931 return resultobj;
20932 fail:
20933 return NULL;
20934 }
20935
20936
20937 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20938 PyObject *resultobj = 0;
20939 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20940 int arg2 ;
20941 void *argp1 = 0 ;
20942 int res1 = 0 ;
20943 int val2 ;
20944 int ecode2 = 0 ;
20945 PyObject *swig_obj[2] ;
20946
20947 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20949 if (!SWIG_IsOK(res1)) {
20950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20951 }
20952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20953 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20954 if (!SWIG_IsOK(ecode2)) {
20955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20956 }
20957 arg2 = static_cast< int >(val2);
20958 if (arg1) (arg1)->m_y = arg2;
20959
20960 resultobj = SWIG_Py_Void();
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20968 PyObject *resultobj = 0;
20969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20970 int result;
20971 void *argp1 = 0 ;
20972 int res1 = 0 ;
20973 PyObject *swig_obj[1] ;
20974
20975 if (!args) SWIG_fail;
20976 swig_obj[0] = args;
20977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20978 if (!SWIG_IsOK(res1)) {
20979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20980 }
20981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20982 result = (int) ((arg1)->m_y);
20983 resultobj = SWIG_From_int(static_cast< int >(result));
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20991 PyObject *resultobj = 0;
20992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20993 bool arg2 ;
20994 void *argp1 = 0 ;
20995 int res1 = 0 ;
20996 bool val2 ;
20997 int ecode2 = 0 ;
20998 PyObject *swig_obj[2] ;
20999
21000 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
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_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21004 }
21005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21006 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21007 if (!SWIG_IsOK(ecode2)) {
21008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21009 }
21010 arg2 = static_cast< bool >(val2);
21011 if (arg1) (arg1)->m_leftDown = arg2;
21012
21013 resultobj = SWIG_Py_Void();
21014 return resultobj;
21015 fail:
21016 return NULL;
21017 }
21018
21019
21020 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21021 PyObject *resultobj = 0;
21022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21023 bool result;
21024 void *argp1 = 0 ;
21025 int res1 = 0 ;
21026 PyObject *swig_obj[1] ;
21027
21028 if (!args) SWIG_fail;
21029 swig_obj[0] = args;
21030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21031 if (!SWIG_IsOK(res1)) {
21032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21033 }
21034 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21035 result = (bool) ((arg1)->m_leftDown);
21036 {
21037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21038 }
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21048 bool arg2 ;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 bool val2 ;
21052 int ecode2 = 0 ;
21053 PyObject *swig_obj[2] ;
21054
21055 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21059 }
21060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21061 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21062 if (!SWIG_IsOK(ecode2)) {
21063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21064 }
21065 arg2 = static_cast< bool >(val2);
21066 if (arg1) (arg1)->m_middleDown = arg2;
21067
21068 resultobj = SWIG_Py_Void();
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21076 PyObject *resultobj = 0;
21077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21078 bool result;
21079 void *argp1 = 0 ;
21080 int res1 = 0 ;
21081 PyObject *swig_obj[1] ;
21082
21083 if (!args) SWIG_fail;
21084 swig_obj[0] = args;
21085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21086 if (!SWIG_IsOK(res1)) {
21087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21088 }
21089 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21090 result = (bool) ((arg1)->m_middleDown);
21091 {
21092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21093 }
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21101 PyObject *resultobj = 0;
21102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21103 bool arg2 ;
21104 void *argp1 = 0 ;
21105 int res1 = 0 ;
21106 bool val2 ;
21107 int ecode2 = 0 ;
21108 PyObject *swig_obj[2] ;
21109
21110 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21112 if (!SWIG_IsOK(res1)) {
21113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21114 }
21115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21116 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21117 if (!SWIG_IsOK(ecode2)) {
21118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21119 }
21120 arg2 = static_cast< bool >(val2);
21121 if (arg1) (arg1)->m_rightDown = arg2;
21122
21123 resultobj = SWIG_Py_Void();
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 PyObject *resultobj = 0;
21132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21133 bool result;
21134 void *argp1 = 0 ;
21135 int res1 = 0 ;
21136 PyObject *swig_obj[1] ;
21137
21138 if (!args) SWIG_fail;
21139 swig_obj[0] = args;
21140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21143 }
21144 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21145 result = (bool) ((arg1)->m_rightDown);
21146 {
21147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21148 }
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21156 PyObject *resultobj = 0;
21157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21158 bool arg2 ;
21159 void *argp1 = 0 ;
21160 int res1 = 0 ;
21161 bool val2 ;
21162 int ecode2 = 0 ;
21163 PyObject *swig_obj[2] ;
21164
21165 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21167 if (!SWIG_IsOK(res1)) {
21168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21169 }
21170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21171 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21172 if (!SWIG_IsOK(ecode2)) {
21173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21174 }
21175 arg2 = static_cast< bool >(val2);
21176 if (arg1) (arg1)->m_controlDown = arg2;
21177
21178 resultobj = SWIG_Py_Void();
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21186 PyObject *resultobj = 0;
21187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21188 bool result;
21189 void *argp1 = 0 ;
21190 int res1 = 0 ;
21191 PyObject *swig_obj[1] ;
21192
21193 if (!args) SWIG_fail;
21194 swig_obj[0] = args;
21195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21196 if (!SWIG_IsOK(res1)) {
21197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21198 }
21199 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21200 result = (bool) ((arg1)->m_controlDown);
21201 {
21202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21203 }
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21211 PyObject *resultobj = 0;
21212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21213 bool arg2 ;
21214 void *argp1 = 0 ;
21215 int res1 = 0 ;
21216 bool val2 ;
21217 int ecode2 = 0 ;
21218 PyObject *swig_obj[2] ;
21219
21220 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21222 if (!SWIG_IsOK(res1)) {
21223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21224 }
21225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21226 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21227 if (!SWIG_IsOK(ecode2)) {
21228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21229 }
21230 arg2 = static_cast< bool >(val2);
21231 if (arg1) (arg1)->m_shiftDown = arg2;
21232
21233 resultobj = SWIG_Py_Void();
21234 return resultobj;
21235 fail:
21236 return NULL;
21237 }
21238
21239
21240 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21241 PyObject *resultobj = 0;
21242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21243 bool result;
21244 void *argp1 = 0 ;
21245 int res1 = 0 ;
21246 PyObject *swig_obj[1] ;
21247
21248 if (!args) SWIG_fail;
21249 swig_obj[0] = args;
21250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21251 if (!SWIG_IsOK(res1)) {
21252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21253 }
21254 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21255 result = (bool) ((arg1)->m_shiftDown);
21256 {
21257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21258 }
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21266 PyObject *resultobj = 0;
21267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21268 bool arg2 ;
21269 void *argp1 = 0 ;
21270 int res1 = 0 ;
21271 bool val2 ;
21272 int ecode2 = 0 ;
21273 PyObject *swig_obj[2] ;
21274
21275 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21279 }
21280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21281 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21282 if (!SWIG_IsOK(ecode2)) {
21283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21284 }
21285 arg2 = static_cast< bool >(val2);
21286 if (arg1) (arg1)->m_altDown = arg2;
21287
21288 resultobj = SWIG_Py_Void();
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21298 bool result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 PyObject *swig_obj[1] ;
21302
21303 if (!args) SWIG_fail;
21304 swig_obj[0] = args;
21305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21306 if (!SWIG_IsOK(res1)) {
21307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21308 }
21309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21310 result = (bool) ((arg1)->m_altDown);
21311 {
21312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21313 }
21314 return resultobj;
21315 fail:
21316 return NULL;
21317 }
21318
21319
21320 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21321 PyObject *resultobj = 0;
21322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21323 bool arg2 ;
21324 void *argp1 = 0 ;
21325 int res1 = 0 ;
21326 bool val2 ;
21327 int ecode2 = 0 ;
21328 PyObject *swig_obj[2] ;
21329
21330 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21332 if (!SWIG_IsOK(res1)) {
21333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21334 }
21335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21336 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21337 if (!SWIG_IsOK(ecode2)) {
21338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21339 }
21340 arg2 = static_cast< bool >(val2);
21341 if (arg1) (arg1)->m_metaDown = arg2;
21342
21343 resultobj = SWIG_Py_Void();
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21351 PyObject *resultobj = 0;
21352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21353 bool result;
21354 void *argp1 = 0 ;
21355 int res1 = 0 ;
21356 PyObject *swig_obj[1] ;
21357
21358 if (!args) SWIG_fail;
21359 swig_obj[0] = args;
21360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21361 if (!SWIG_IsOK(res1)) {
21362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21363 }
21364 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21365 result = (bool) ((arg1)->m_metaDown);
21366 {
21367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21368 }
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21376 PyObject *resultobj = 0;
21377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21378 int arg2 ;
21379 void *argp1 = 0 ;
21380 int res1 = 0 ;
21381 int val2 ;
21382 int ecode2 = 0 ;
21383 PyObject *swig_obj[2] ;
21384
21385 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21389 }
21390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21391 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21392 if (!SWIG_IsOK(ecode2)) {
21393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21394 }
21395 arg2 = static_cast< int >(val2);
21396 if (arg1) (arg1)->m_wheelRotation = arg2;
21397
21398 resultobj = SWIG_Py_Void();
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21406 PyObject *resultobj = 0;
21407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21408 int result;
21409 void *argp1 = 0 ;
21410 int res1 = 0 ;
21411 PyObject *swig_obj[1] ;
21412
21413 if (!args) SWIG_fail;
21414 swig_obj[0] = args;
21415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21416 if (!SWIG_IsOK(res1)) {
21417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21418 }
21419 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21420 result = (int) ((arg1)->m_wheelRotation);
21421 resultobj = SWIG_From_int(static_cast< int >(result));
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21431 int arg2 ;
21432 void *argp1 = 0 ;
21433 int res1 = 0 ;
21434 int val2 ;
21435 int ecode2 = 0 ;
21436 PyObject *swig_obj[2] ;
21437
21438 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21440 if (!SWIG_IsOK(res1)) {
21441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21442 }
21443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21444 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21445 if (!SWIG_IsOK(ecode2)) {
21446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21447 }
21448 arg2 = static_cast< int >(val2);
21449 if (arg1) (arg1)->m_wheelDelta = arg2;
21450
21451 resultobj = SWIG_Py_Void();
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21459 PyObject *resultobj = 0;
21460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21461 int result;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 PyObject *swig_obj[1] ;
21465
21466 if (!args) SWIG_fail;
21467 swig_obj[0] = args;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21471 }
21472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21473 result = (int) ((arg1)->m_wheelDelta);
21474 resultobj = SWIG_From_int(static_cast< int >(result));
21475 return resultobj;
21476 fail:
21477 return NULL;
21478 }
21479
21480
21481 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21482 PyObject *resultobj = 0;
21483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21484 int arg2 ;
21485 void *argp1 = 0 ;
21486 int res1 = 0 ;
21487 int val2 ;
21488 int ecode2 = 0 ;
21489 PyObject *swig_obj[2] ;
21490
21491 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
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_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21495 }
21496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21498 if (!SWIG_IsOK(ecode2)) {
21499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21500 }
21501 arg2 = static_cast< int >(val2);
21502 if (arg1) (arg1)->m_linesPerAction = arg2;
21503
21504 resultobj = SWIG_Py_Void();
21505 return resultobj;
21506 fail:
21507 return NULL;
21508 }
21509
21510
21511 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21512 PyObject *resultobj = 0;
21513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21514 int result;
21515 void *argp1 = 0 ;
21516 int res1 = 0 ;
21517 PyObject *swig_obj[1] ;
21518
21519 if (!args) SWIG_fail;
21520 swig_obj[0] = args;
21521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21522 if (!SWIG_IsOK(res1)) {
21523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21524 }
21525 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21526 result = (int) ((arg1)->m_linesPerAction);
21527 resultobj = SWIG_From_int(static_cast< int >(result));
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *obj;
21536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21537 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21538 return SWIG_Py_Void();
21539 }
21540
21541 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21542 return SWIG_Python_InitShadowInstance(args);
21543 }
21544
21545 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21546 PyObject *resultobj = 0;
21547 int arg1 = (int) 0 ;
21548 int arg2 = (int) 0 ;
21549 wxSetCursorEvent *result = 0 ;
21550 int val1 ;
21551 int ecode1 = 0 ;
21552 int val2 ;
21553 int ecode2 = 0 ;
21554 PyObject * obj0 = 0 ;
21555 PyObject * obj1 = 0 ;
21556 char * kwnames[] = {
21557 (char *) "x",(char *) "y", NULL
21558 };
21559
21560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21561 if (obj0) {
21562 ecode1 = SWIG_AsVal_int(obj0, &val1);
21563 if (!SWIG_IsOK(ecode1)) {
21564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21565 }
21566 arg1 = static_cast< int >(val1);
21567 }
21568 if (obj1) {
21569 ecode2 = SWIG_AsVal_int(obj1, &val2);
21570 if (!SWIG_IsOK(ecode2)) {
21571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21572 }
21573 arg2 = static_cast< int >(val2);
21574 }
21575 {
21576 PyThreadState* __tstate = wxPyBeginAllowThreads();
21577 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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_wxSetCursorEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21601 }
21602 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 resultobj = SWIG_From_int(static_cast< int >(result));
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 PyObject *resultobj = 0;
21618 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21619 int result;
21620 void *argp1 = 0 ;
21621 int res1 = 0 ;
21622 PyObject *swig_obj[1] ;
21623
21624 if (!args) SWIG_fail;
21625 swig_obj[0] = args;
21626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21627 if (!SWIG_IsOK(res1)) {
21628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21629 }
21630 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_From_int(static_cast< int >(result));
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj = 0;
21646 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21647 wxCursor *arg2 = 0 ;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 void *argp2 = 0 ;
21651 int res2 = 0 ;
21652 PyObject * obj0 = 0 ;
21653 PyObject * obj1 = 0 ;
21654 char * kwnames[] = {
21655 (char *) "self",(char *) "cursor", NULL
21656 };
21657
21658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21660 if (!SWIG_IsOK(res1)) {
21661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21662 }
21663 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21664 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21665 if (!SWIG_IsOK(res2)) {
21666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21667 }
21668 if (!argp2) {
21669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21670 }
21671 arg2 = reinterpret_cast< wxCursor * >(argp2);
21672 {
21673 PyThreadState* __tstate = wxPyBeginAllowThreads();
21674 (arg1)->SetCursor((wxCursor const &)*arg2);
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 resultobj = SWIG_Py_Void();
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 PyObject *resultobj = 0;
21687 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21688 wxCursor *result = 0 ;
21689 void *argp1 = 0 ;
21690 int res1 = 0 ;
21691 PyObject *swig_obj[1] ;
21692
21693 if (!args) SWIG_fail;
21694 swig_obj[0] = args;
21695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21696 if (!SWIG_IsOK(res1)) {
21697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21698 }
21699 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 {
21703 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21704 result = (wxCursor *) &_result_ref;
21705 }
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 {
21710 wxCursor* resultptr = new wxCursor(*result);
21711 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21712 }
21713 return resultobj;
21714 fail:
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21720 PyObject *resultobj = 0;
21721 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21722 bool result;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21732 }
21733 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 {
21741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21742 }
21743 return resultobj;
21744 fail:
21745 return NULL;
21746 }
21747
21748
21749 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21750 PyObject *obj;
21751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21752 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21753 return SWIG_Py_Void();
21754 }
21755
21756 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 return SWIG_Python_InitShadowInstance(args);
21758 }
21759
21760 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21761 PyObject *resultobj = 0;
21762 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21763 wxKeyEvent *result = 0 ;
21764 int val1 ;
21765 int ecode1 = 0 ;
21766 PyObject * obj0 = 0 ;
21767 char * kwnames[] = {
21768 (char *) "eventType", NULL
21769 };
21770
21771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21772 if (obj0) {
21773 ecode1 = SWIG_AsVal_int(obj0, &val1);
21774 if (!SWIG_IsOK(ecode1)) {
21775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21776 }
21777 arg1 = static_cast< wxEventType >(val1);
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21786 return resultobj;
21787 fail:
21788 return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21793 PyObject *resultobj = 0;
21794 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21795 int result;
21796 void *argp1 = 0 ;
21797 int res1 = 0 ;
21798 PyObject *swig_obj[1] ;
21799
21800 if (!args) SWIG_fail;
21801 swig_obj[0] = args;
21802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21803 if (!SWIG_IsOK(res1)) {
21804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21805 }
21806 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 resultobj = SWIG_From_int(static_cast< int >(result));
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821 PyObject *resultobj = 0;
21822 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21823 bool result;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 PyObject *swig_obj[1] ;
21827
21828 if (!args) SWIG_fail;
21829 swig_obj[0] = args;
21830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21831 if (!SWIG_IsOK(res1)) {
21832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21833 }
21834 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21835 {
21836 PyThreadState* __tstate = wxPyBeginAllowThreads();
21837 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21838 wxPyEndAllowThreads(__tstate);
21839 if (PyErr_Occurred()) SWIG_fail;
21840 }
21841 {
21842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21843 }
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21853 bool result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 PyObject *swig_obj[1] ;
21857
21858 if (!args) SWIG_fail;
21859 swig_obj[0] = args;
21860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21863 }
21864 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21873 }
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881 PyObject *resultobj = 0;
21882 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21883 bool result;
21884 void *argp1 = 0 ;
21885 int res1 = 0 ;
21886 PyObject *swig_obj[1] ;
21887
21888 if (!args) SWIG_fail;
21889 swig_obj[0] = args;
21890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21891 if (!SWIG_IsOK(res1)) {
21892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21893 }
21894 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21895 {
21896 PyThreadState* __tstate = wxPyBeginAllowThreads();
21897 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 {
21902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21903 }
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21911 PyObject *resultobj = 0;
21912 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21913 bool result;
21914 void *argp1 = 0 ;
21915 int res1 = 0 ;
21916 PyObject *swig_obj[1] ;
21917
21918 if (!args) SWIG_fail;
21919 swig_obj[0] = args;
21920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21921 if (!SWIG_IsOK(res1)) {
21922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21923 }
21924 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 {
21932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21933 }
21934 return resultobj;
21935 fail:
21936 return NULL;
21937 }
21938
21939
21940 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21941 PyObject *resultobj = 0;
21942 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21943 bool result;
21944 void *argp1 = 0 ;
21945 int res1 = 0 ;
21946 PyObject *swig_obj[1] ;
21947
21948 if (!args) SWIG_fail;
21949 swig_obj[0] = args;
21950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21951 if (!SWIG_IsOK(res1)) {
21952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21953 }
21954 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21958 wxPyEndAllowThreads(__tstate);
21959 if (PyErr_Occurred()) SWIG_fail;
21960 }
21961 {
21962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21963 }
21964 return resultobj;
21965 fail:
21966 return NULL;
21967 }
21968
21969
21970 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21971 PyObject *resultobj = 0;
21972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21973 bool result;
21974 void *argp1 = 0 ;
21975 int res1 = 0 ;
21976 PyObject *swig_obj[1] ;
21977
21978 if (!args) SWIG_fail;
21979 swig_obj[0] = args;
21980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21981 if (!SWIG_IsOK(res1)) {
21982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21983 }
21984 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21988 wxPyEndAllowThreads(__tstate);
21989 if (PyErr_Occurred()) SWIG_fail;
21990 }
21991 {
21992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21993 }
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22003 int result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_int(static_cast< int >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029 PyObject *resultobj = 0;
22030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22031 int result;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 PyObject *swig_obj[1] ;
22035
22036 if (!args) SWIG_fail;
22037 swig_obj[0] = args;
22038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22039 if (!SWIG_IsOK(res1)) {
22040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22041 }
22042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 resultobj = SWIG_From_int(static_cast< int >(result));
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22057 PyObject *resultobj = 0;
22058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22059 unsigned int result;
22060 void *argp1 = 0 ;
22061 int res1 = 0 ;
22062 PyObject *swig_obj[1] ;
22063
22064 if (!args) SWIG_fail;
22065 swig_obj[0] = args;
22066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22069 }
22070 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22087 unsigned int result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22113 PyObject *resultobj = 0;
22114 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22115 wxPoint result;
22116 void *argp1 = 0 ;
22117 int res1 = 0 ;
22118 PyObject *swig_obj[1] ;
22119
22120 if (!args) SWIG_fail;
22121 swig_obj[0] = args;
22122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22123 if (!SWIG_IsOK(res1)) {
22124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22125 }
22126 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22127 {
22128 PyThreadState* __tstate = wxPyBeginAllowThreads();
22129 result = (arg1)->GetPosition();
22130 wxPyEndAllowThreads(__tstate);
22131 if (PyErr_Occurred()) SWIG_fail;
22132 }
22133 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22141 PyObject *resultobj = 0;
22142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22143 long *arg2 = (long *) 0 ;
22144 long *arg3 = (long *) 0 ;
22145 void *argp1 = 0 ;
22146 int res1 = 0 ;
22147 long temp2 ;
22148 int res2 = SWIG_TMPOBJ ;
22149 long temp3 ;
22150 int res3 = SWIG_TMPOBJ ;
22151 PyObject *swig_obj[1] ;
22152
22153 arg2 = &temp2;
22154 arg3 = &temp3;
22155 if (!args) SWIG_fail;
22156 swig_obj[0] = args;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22160 }
22161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 (arg1)->GetPosition(arg2,arg3);
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 resultobj = SWIG_Py_Void();
22169 if (SWIG_IsTmpObj(res2)) {
22170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22171 } else {
22172 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22174 }
22175 if (SWIG_IsTmpObj(res3)) {
22176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22177 } else {
22178 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22180 }
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22188 PyObject *resultobj = 0;
22189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22190 int result;
22191 void *argp1 = 0 ;
22192 int res1 = 0 ;
22193 PyObject *swig_obj[1] ;
22194
22195 if (!args) SWIG_fail;
22196 swig_obj[0] = args;
22197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22198 if (!SWIG_IsOK(res1)) {
22199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22200 }
22201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (int)((wxKeyEvent const *)arg1)->GetX();
22205 wxPyEndAllowThreads(__tstate);
22206 if (PyErr_Occurred()) SWIG_fail;
22207 }
22208 resultobj = SWIG_From_int(static_cast< int >(result));
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22216 PyObject *resultobj = 0;
22217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22218 int result;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject *swig_obj[1] ;
22222
22223 if (!args) SWIG_fail;
22224 swig_obj[0] = args;
22225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22226 if (!SWIG_IsOK(res1)) {
22227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22228 }
22229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (int)((wxKeyEvent const *)arg1)->GetY();
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 resultobj = SWIG_From_int(static_cast< int >(result));
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22244 PyObject *resultobj = 0;
22245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22246 int arg2 ;
22247 void *argp1 = 0 ;
22248 int res1 = 0 ;
22249 int val2 ;
22250 int ecode2 = 0 ;
22251 PyObject *swig_obj[2] ;
22252
22253 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22255 if (!SWIG_IsOK(res1)) {
22256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22257 }
22258 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22259 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22260 if (!SWIG_IsOK(ecode2)) {
22261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22262 }
22263 arg2 = static_cast< int >(val2);
22264 if (arg1) (arg1)->m_x = arg2;
22265
22266 resultobj = SWIG_Py_Void();
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22274 PyObject *resultobj = 0;
22275 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22276 int result;
22277 void *argp1 = 0 ;
22278 int res1 = 0 ;
22279 PyObject *swig_obj[1] ;
22280
22281 if (!args) SWIG_fail;
22282 swig_obj[0] = args;
22283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22284 if (!SWIG_IsOK(res1)) {
22285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22286 }
22287 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22288 result = (int) ((arg1)->m_x);
22289 resultobj = SWIG_From_int(static_cast< int >(result));
22290 return resultobj;
22291 fail:
22292 return NULL;
22293 }
22294
22295
22296 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22297 PyObject *resultobj = 0;
22298 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22299 int arg2 ;
22300 void *argp1 = 0 ;
22301 int res1 = 0 ;
22302 int val2 ;
22303 int ecode2 = 0 ;
22304 PyObject *swig_obj[2] ;
22305
22306 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22308 if (!SWIG_IsOK(res1)) {
22309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22310 }
22311 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22312 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22313 if (!SWIG_IsOK(ecode2)) {
22314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22315 }
22316 arg2 = static_cast< int >(val2);
22317 if (arg1) (arg1)->m_y = arg2;
22318
22319 resultobj = SWIG_Py_Void();
22320 return resultobj;
22321 fail:
22322 return NULL;
22323 }
22324
22325
22326 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22327 PyObject *resultobj = 0;
22328 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22329 int result;
22330 void *argp1 = 0 ;
22331 int res1 = 0 ;
22332 PyObject *swig_obj[1] ;
22333
22334 if (!args) SWIG_fail;
22335 swig_obj[0] = args;
22336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22337 if (!SWIG_IsOK(res1)) {
22338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22339 }
22340 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22341 result = (int) ((arg1)->m_y);
22342 resultobj = SWIG_From_int(static_cast< int >(result));
22343 return resultobj;
22344 fail:
22345 return NULL;
22346 }
22347
22348
22349 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22350 PyObject *resultobj = 0;
22351 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22352 long arg2 ;
22353 void *argp1 = 0 ;
22354 int res1 = 0 ;
22355 long val2 ;
22356 int ecode2 = 0 ;
22357 PyObject *swig_obj[2] ;
22358
22359 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
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_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22363 }
22364 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22365 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22366 if (!SWIG_IsOK(ecode2)) {
22367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22368 }
22369 arg2 = static_cast< long >(val2);
22370 if (arg1) (arg1)->m_keyCode = arg2;
22371
22372 resultobj = SWIG_Py_Void();
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22380 PyObject *resultobj = 0;
22381 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22382 long result;
22383 void *argp1 = 0 ;
22384 int res1 = 0 ;
22385 PyObject *swig_obj[1] ;
22386
22387 if (!args) SWIG_fail;
22388 swig_obj[0] = args;
22389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22390 if (!SWIG_IsOK(res1)) {
22391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22392 }
22393 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22394 result = (long) ((arg1)->m_keyCode);
22395 resultobj = SWIG_From_long(static_cast< long >(result));
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22403 PyObject *resultobj = 0;
22404 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22405 bool arg2 ;
22406 void *argp1 = 0 ;
22407 int res1 = 0 ;
22408 bool val2 ;
22409 int ecode2 = 0 ;
22410 PyObject *swig_obj[2] ;
22411
22412 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
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_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22416 }
22417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22418 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22419 if (!SWIG_IsOK(ecode2)) {
22420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22421 }
22422 arg2 = static_cast< bool >(val2);
22423 if (arg1) (arg1)->m_controlDown = arg2;
22424
22425 resultobj = SWIG_Py_Void();
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 bool result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 result = (bool) ((arg1)->m_controlDown);
22448 {
22449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22450 }
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22458 PyObject *resultobj = 0;
22459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22460 bool arg2 ;
22461 void *argp1 = 0 ;
22462 int res1 = 0 ;
22463 bool val2 ;
22464 int ecode2 = 0 ;
22465 PyObject *swig_obj[2] ;
22466
22467 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22469 if (!SWIG_IsOK(res1)) {
22470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22471 }
22472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22473 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22474 if (!SWIG_IsOK(ecode2)) {
22475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22476 }
22477 arg2 = static_cast< bool >(val2);
22478 if (arg1) (arg1)->m_shiftDown = arg2;
22479
22480 resultobj = SWIG_Py_Void();
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22488 PyObject *resultobj = 0;
22489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22490 bool result;
22491 void *argp1 = 0 ;
22492 int res1 = 0 ;
22493 PyObject *swig_obj[1] ;
22494
22495 if (!args) SWIG_fail;
22496 swig_obj[0] = args;
22497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22498 if (!SWIG_IsOK(res1)) {
22499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22500 }
22501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22502 result = (bool) ((arg1)->m_shiftDown);
22503 {
22504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22505 }
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 PyObject *resultobj = 0;
22514 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22515 bool arg2 ;
22516 void *argp1 = 0 ;
22517 int res1 = 0 ;
22518 bool val2 ;
22519 int ecode2 = 0 ;
22520 PyObject *swig_obj[2] ;
22521
22522 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22524 if (!SWIG_IsOK(res1)) {
22525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22526 }
22527 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22528 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22529 if (!SWIG_IsOK(ecode2)) {
22530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22531 }
22532 arg2 = static_cast< bool >(val2);
22533 if (arg1) (arg1)->m_altDown = arg2;
22534
22535 resultobj = SWIG_Py_Void();
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22543 PyObject *resultobj = 0;
22544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22545 bool result;
22546 void *argp1 = 0 ;
22547 int res1 = 0 ;
22548 PyObject *swig_obj[1] ;
22549
22550 if (!args) SWIG_fail;
22551 swig_obj[0] = args;
22552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22553 if (!SWIG_IsOK(res1)) {
22554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22555 }
22556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22557 result = (bool) ((arg1)->m_altDown);
22558 {
22559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22560 }
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22568 PyObject *resultobj = 0;
22569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22570 bool arg2 ;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 bool val2 ;
22574 int ecode2 = 0 ;
22575 PyObject *swig_obj[2] ;
22576
22577 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22579 if (!SWIG_IsOK(res1)) {
22580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22581 }
22582 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22583 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22584 if (!SWIG_IsOK(ecode2)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22586 }
22587 arg2 = static_cast< bool >(val2);
22588 if (arg1) (arg1)->m_metaDown = arg2;
22589
22590 resultobj = SWIG_Py_Void();
22591 return resultobj;
22592 fail:
22593 return NULL;
22594 }
22595
22596
22597 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22598 PyObject *resultobj = 0;
22599 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22600 bool result;
22601 void *argp1 = 0 ;
22602 int res1 = 0 ;
22603 PyObject *swig_obj[1] ;
22604
22605 if (!args) SWIG_fail;
22606 swig_obj[0] = args;
22607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22608 if (!SWIG_IsOK(res1)) {
22609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22610 }
22611 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22612 result = (bool) ((arg1)->m_metaDown);
22613 {
22614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22615 }
22616 return resultobj;
22617 fail:
22618 return NULL;
22619 }
22620
22621
22622 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22623 PyObject *resultobj = 0;
22624 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22625 bool arg2 ;
22626 void *argp1 = 0 ;
22627 int res1 = 0 ;
22628 bool val2 ;
22629 int ecode2 = 0 ;
22630 PyObject *swig_obj[2] ;
22631
22632 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22634 if (!SWIG_IsOK(res1)) {
22635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22636 }
22637 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22638 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22639 if (!SWIG_IsOK(ecode2)) {
22640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22641 }
22642 arg2 = static_cast< bool >(val2);
22643 if (arg1) (arg1)->m_scanCode = arg2;
22644
22645 resultobj = SWIG_Py_Void();
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22653 PyObject *resultobj = 0;
22654 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22655 bool result;
22656 void *argp1 = 0 ;
22657 int res1 = 0 ;
22658 PyObject *swig_obj[1] ;
22659
22660 if (!args) SWIG_fail;
22661 swig_obj[0] = args;
22662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22663 if (!SWIG_IsOK(res1)) {
22664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22665 }
22666 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22667 result = (bool) ((arg1)->m_scanCode);
22668 {
22669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22670 }
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 unsigned int arg2 ;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 unsigned int val2 ;
22684 int ecode2 = 0 ;
22685 PyObject *swig_obj[2] ;
22686
22687 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22689 if (!SWIG_IsOK(res1)) {
22690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22691 }
22692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22693 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22694 if (!SWIG_IsOK(ecode2)) {
22695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22696 }
22697 arg2 = static_cast< unsigned int >(val2);
22698 if (arg1) (arg1)->m_rawCode = arg2;
22699
22700 resultobj = SWIG_Py_Void();
22701 return resultobj;
22702 fail:
22703 return NULL;
22704 }
22705
22706
22707 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22708 PyObject *resultobj = 0;
22709 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22710 unsigned int result;
22711 void *argp1 = 0 ;
22712 int res1 = 0 ;
22713 PyObject *swig_obj[1] ;
22714
22715 if (!args) SWIG_fail;
22716 swig_obj[0] = args;
22717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22718 if (!SWIG_IsOK(res1)) {
22719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22720 }
22721 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22722 result = (unsigned int) ((arg1)->m_rawCode);
22723 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22731 PyObject *resultobj = 0;
22732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22733 unsigned int arg2 ;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 unsigned int val2 ;
22737 int ecode2 = 0 ;
22738 PyObject *swig_obj[2] ;
22739
22740 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22742 if (!SWIG_IsOK(res1)) {
22743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22744 }
22745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22746 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22747 if (!SWIG_IsOK(ecode2)) {
22748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22749 }
22750 arg2 = static_cast< unsigned int >(val2);
22751 if (arg1) (arg1)->m_rawFlags = arg2;
22752
22753 resultobj = SWIG_Py_Void();
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22761 PyObject *resultobj = 0;
22762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22763 unsigned int result;
22764 void *argp1 = 0 ;
22765 int res1 = 0 ;
22766 PyObject *swig_obj[1] ;
22767
22768 if (!args) SWIG_fail;
22769 swig_obj[0] = args;
22770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22771 if (!SWIG_IsOK(res1)) {
22772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22773 }
22774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22775 result = (unsigned int) ((arg1)->m_rawFlags);
22776 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 PyObject *obj;
22785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22786 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22787 return SWIG_Py_Void();
22788 }
22789
22790 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 return SWIG_Python_InitShadowInstance(args);
22792 }
22793
22794 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22795 PyObject *resultobj = 0;
22796 wxSize const &arg1_defvalue = wxDefaultSize ;
22797 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22798 int arg2 = (int) 0 ;
22799 wxSizeEvent *result = 0 ;
22800 wxSize temp1 ;
22801 int val2 ;
22802 int ecode2 = 0 ;
22803 PyObject * obj0 = 0 ;
22804 PyObject * obj1 = 0 ;
22805 char * kwnames[] = {
22806 (char *) "sz",(char *) "winid", NULL
22807 };
22808
22809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22810 if (obj0) {
22811 {
22812 arg1 = &temp1;
22813 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22814 }
22815 }
22816 if (obj1) {
22817 ecode2 = SWIG_AsVal_int(obj1, &val2);
22818 if (!SWIG_IsOK(ecode2)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22820 }
22821 arg2 = static_cast< int >(val2);
22822 }
22823 {
22824 PyThreadState* __tstate = wxPyBeginAllowThreads();
22825 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22826 wxPyEndAllowThreads(__tstate);
22827 if (PyErr_Occurred()) SWIG_fail;
22828 }
22829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22830 return resultobj;
22831 fail:
22832 return NULL;
22833 }
22834
22835
22836 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22837 PyObject *resultobj = 0;
22838 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22839 wxSize result;
22840 void *argp1 = 0 ;
22841 int res1 = 0 ;
22842 PyObject *swig_obj[1] ;
22843
22844 if (!args) SWIG_fail;
22845 swig_obj[0] = args;
22846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22847 if (!SWIG_IsOK(res1)) {
22848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22849 }
22850 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22851 {
22852 PyThreadState* __tstate = wxPyBeginAllowThreads();
22853 result = ((wxSizeEvent const *)arg1)->GetSize();
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22865 PyObject *resultobj = 0;
22866 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22867 wxRect result;
22868 void *argp1 = 0 ;
22869 int res1 = 0 ;
22870 PyObject *swig_obj[1] ;
22871
22872 if (!args) SWIG_fail;
22873 swig_obj[0] = args;
22874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22877 }
22878 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22879 {
22880 PyThreadState* __tstate = wxPyBeginAllowThreads();
22881 result = ((wxSizeEvent const *)arg1)->GetRect();
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22886 return resultobj;
22887 fail:
22888 return NULL;
22889 }
22890
22891
22892 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22893 PyObject *resultobj = 0;
22894 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22895 wxRect arg2 ;
22896 void *argp1 = 0 ;
22897 int res1 = 0 ;
22898 void *argp2 ;
22899 int res2 = 0 ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char * kwnames[] = {
22903 (char *) "self",(char *) "rect", NULL
22904 };
22905
22906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22912 {
22913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22914 if (!SWIG_IsOK(res2)) {
22915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22916 }
22917 if (!argp2) {
22918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22919 } else {
22920 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22921 arg2 = *temp;
22922 if (SWIG_IsNewObj(res2)) delete temp;
22923 }
22924 }
22925 {
22926 PyThreadState* __tstate = wxPyBeginAllowThreads();
22927 (arg1)->SetRect(arg2);
22928 wxPyEndAllowThreads(__tstate);
22929 if (PyErr_Occurred()) SWIG_fail;
22930 }
22931 resultobj = SWIG_Py_Void();
22932 return resultobj;
22933 fail:
22934 return NULL;
22935 }
22936
22937
22938 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22939 PyObject *resultobj = 0;
22940 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22941 wxSize arg2 ;
22942 void *argp1 = 0 ;
22943 int res1 = 0 ;
22944 void *argp2 ;
22945 int res2 = 0 ;
22946 PyObject * obj0 = 0 ;
22947 PyObject * obj1 = 0 ;
22948 char * kwnames[] = {
22949 (char *) "self",(char *) "size", NULL
22950 };
22951
22952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22954 if (!SWIG_IsOK(res1)) {
22955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22956 }
22957 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22958 {
22959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22960 if (!SWIG_IsOK(res2)) {
22961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22962 }
22963 if (!argp2) {
22964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22965 } else {
22966 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22967 arg2 = *temp;
22968 if (SWIG_IsNewObj(res2)) delete temp;
22969 }
22970 }
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 wxSizeEvent_SetSize(arg1,arg2);
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 resultobj = SWIG_Py_Void();
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 PyObject *resultobj = 0;
22986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22987 wxSize *arg2 = (wxSize *) 0 ;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 void *argp2 = 0 ;
22991 int res2 = 0 ;
22992 PyObject *swig_obj[2] ;
22993
22994 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
22995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22996 if (!SWIG_IsOK(res1)) {
22997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22998 }
22999 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23000 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23001 if (!SWIG_IsOK(res2)) {
23002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23003 }
23004 arg2 = reinterpret_cast< wxSize * >(argp2);
23005 if (arg1) (arg1)->m_size = *arg2;
23006
23007 resultobj = SWIG_Py_Void();
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23017 wxSize *result = 0 ;
23018 void *argp1 = 0 ;
23019 int res1 = 0 ;
23020 PyObject *swig_obj[1] ;
23021
23022 if (!args) SWIG_fail;
23023 swig_obj[0] = args;
23024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23025 if (!SWIG_IsOK(res1)) {
23026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23027 }
23028 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23029 result = (wxSize *)& ((arg1)->m_size);
23030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23038 PyObject *resultobj = 0;
23039 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23040 wxRect *arg2 = (wxRect *) 0 ;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 void *argp2 = 0 ;
23044 int res2 = 0 ;
23045 PyObject *swig_obj[2] ;
23046
23047 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23049 if (!SWIG_IsOK(res1)) {
23050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23051 }
23052 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23053 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23054 if (!SWIG_IsOK(res2)) {
23055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23056 }
23057 arg2 = reinterpret_cast< wxRect * >(argp2);
23058 if (arg1) (arg1)->m_rect = *arg2;
23059
23060 resultobj = SWIG_Py_Void();
23061 return resultobj;
23062 fail:
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23068 PyObject *resultobj = 0;
23069 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23070 wxRect *result = 0 ;
23071 void *argp1 = 0 ;
23072 int res1 = 0 ;
23073 PyObject *swig_obj[1] ;
23074
23075 if (!args) SWIG_fail;
23076 swig_obj[0] = args;
23077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23080 }
23081 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23082 result = (wxRect *)& ((arg1)->m_rect);
23083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23091 PyObject *obj;
23092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23093 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23094 return SWIG_Py_Void();
23095 }
23096
23097 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 return SWIG_Python_InitShadowInstance(args);
23099 }
23100
23101 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23102 PyObject *resultobj = 0;
23103 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23104 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23105 int arg2 = (int) 0 ;
23106 wxMoveEvent *result = 0 ;
23107 wxPoint temp1 ;
23108 int val2 ;
23109 int ecode2 = 0 ;
23110 PyObject * obj0 = 0 ;
23111 PyObject * obj1 = 0 ;
23112 char * kwnames[] = {
23113 (char *) "pos",(char *) "winid", NULL
23114 };
23115
23116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23117 if (obj0) {
23118 {
23119 arg1 = &temp1;
23120 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23121 }
23122 }
23123 if (obj1) {
23124 ecode2 = SWIG_AsVal_int(obj1, &val2);
23125 if (!SWIG_IsOK(ecode2)) {
23126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23127 }
23128 arg2 = static_cast< int >(val2);
23129 }
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23144 PyObject *resultobj = 0;
23145 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23146 wxPoint result;
23147 void *argp1 = 0 ;
23148 int res1 = 0 ;
23149 PyObject *swig_obj[1] ;
23150
23151 if (!args) SWIG_fail;
23152 swig_obj[0] = args;
23153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23156 }
23157 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = ((wxMoveEvent const *)arg1)->GetPosition();
23161 wxPyEndAllowThreads(__tstate);
23162 if (PyErr_Occurred()) SWIG_fail;
23163 }
23164 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23174 wxRect result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23184 }
23185 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = ((wxMoveEvent const *)arg1)->GetRect();
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23200 PyObject *resultobj = 0;
23201 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23202 wxRect *arg2 = 0 ;
23203 void *argp1 = 0 ;
23204 int res1 = 0 ;
23205 wxRect temp2 ;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char * kwnames[] = {
23209 (char *) "self",(char *) "rect", NULL
23210 };
23211
23212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23214 if (!SWIG_IsOK(res1)) {
23215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23216 }
23217 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23218 {
23219 arg2 = &temp2;
23220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23221 }
23222 {
23223 PyThreadState* __tstate = wxPyBeginAllowThreads();
23224 (arg1)->SetRect((wxRect const &)*arg2);
23225 wxPyEndAllowThreads(__tstate);
23226 if (PyErr_Occurred()) SWIG_fail;
23227 }
23228 resultobj = SWIG_Py_Void();
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23236 PyObject *resultobj = 0;
23237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23238 wxPoint *arg2 = 0 ;
23239 void *argp1 = 0 ;
23240 int res1 = 0 ;
23241 wxPoint temp2 ;
23242 PyObject * obj0 = 0 ;
23243 PyObject * obj1 = 0 ;
23244 char * kwnames[] = {
23245 (char *) "self",(char *) "pos", NULL
23246 };
23247
23248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23252 }
23253 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23254 {
23255 arg2 = &temp2;
23256 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 (arg1)->SetPosition((wxPoint const &)*arg2);
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 resultobj = SWIG_Py_Void();
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23272 PyObject *obj;
23273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23274 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23275 return SWIG_Py_Void();
23276 }
23277
23278 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23279 return SWIG_Python_InitShadowInstance(args);
23280 }
23281
23282 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23283 PyObject *resultobj = 0;
23284 int arg1 = (int) 0 ;
23285 wxPaintEvent *result = 0 ;
23286 int val1 ;
23287 int ecode1 = 0 ;
23288 PyObject * obj0 = 0 ;
23289 char * kwnames[] = {
23290 (char *) "Id", NULL
23291 };
23292
23293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23294 if (obj0) {
23295 ecode1 = SWIG_AsVal_int(obj0, &val1);
23296 if (!SWIG_IsOK(ecode1)) {
23297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23298 }
23299 arg1 = static_cast< int >(val1);
23300 }
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23315 PyObject *obj;
23316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23318 return SWIG_Py_Void();
23319 }
23320
23321 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 return SWIG_Python_InitShadowInstance(args);
23323 }
23324
23325 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23326 PyObject *resultobj = 0;
23327 int arg1 = (int) 0 ;
23328 wxNcPaintEvent *result = 0 ;
23329 int val1 ;
23330 int ecode1 = 0 ;
23331 PyObject * obj0 = 0 ;
23332 char * kwnames[] = {
23333 (char *) "winid", NULL
23334 };
23335
23336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23337 if (obj0) {
23338 ecode1 = SWIG_AsVal_int(obj0, &val1);
23339 if (!SWIG_IsOK(ecode1)) {
23340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23341 }
23342 arg1 = static_cast< int >(val1);
23343 }
23344 {
23345 PyThreadState* __tstate = wxPyBeginAllowThreads();
23346 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23358 PyObject *obj;
23359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23360 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23361 return SWIG_Py_Void();
23362 }
23363
23364 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23365 return SWIG_Python_InitShadowInstance(args);
23366 }
23367
23368 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj = 0;
23370 int arg1 = (int) 0 ;
23371 wxDC *arg2 = (wxDC *) NULL ;
23372 wxEraseEvent *result = 0 ;
23373 int val1 ;
23374 int ecode1 = 0 ;
23375 void *argp2 = 0 ;
23376 int res2 = 0 ;
23377 PyObject * obj0 = 0 ;
23378 PyObject * obj1 = 0 ;
23379 char * kwnames[] = {
23380 (char *) "Id",(char *) "dc", NULL
23381 };
23382
23383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23384 if (obj0) {
23385 ecode1 = SWIG_AsVal_int(obj0, &val1);
23386 if (!SWIG_IsOK(ecode1)) {
23387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23388 }
23389 arg1 = static_cast< int >(val1);
23390 }
23391 if (obj1) {
23392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23393 if (!SWIG_IsOK(res2)) {
23394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23395 }
23396 arg2 = reinterpret_cast< wxDC * >(argp2);
23397 }
23398 {
23399 PyThreadState* __tstate = wxPyBeginAllowThreads();
23400 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23414 wxDC *result = 0 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 PyObject *swig_obj[1] ;
23418
23419 if (!args) SWIG_fail;
23420 swig_obj[0] = args;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23424 }
23425 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = wxPyMake_wxObject(result, (bool)0);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *obj;
23443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23444 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23445 return SWIG_Py_Void();
23446 }
23447
23448 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23449 return SWIG_Python_InitShadowInstance(args);
23450 }
23451
23452 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23453 PyObject *resultobj = 0;
23454 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23455 int arg2 = (int) 0 ;
23456 wxFocusEvent *result = 0 ;
23457 int val1 ;
23458 int ecode1 = 0 ;
23459 int val2 ;
23460 int ecode2 = 0 ;
23461 PyObject * obj0 = 0 ;
23462 PyObject * obj1 = 0 ;
23463 char * kwnames[] = {
23464 (char *) "type",(char *) "winid", NULL
23465 };
23466
23467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23468 if (obj0) {
23469 ecode1 = SWIG_AsVal_int(obj0, &val1);
23470 if (!SWIG_IsOK(ecode1)) {
23471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23472 }
23473 arg1 = static_cast< wxEventType >(val1);
23474 }
23475 if (obj1) {
23476 ecode2 = SWIG_AsVal_int(obj1, &val2);
23477 if (!SWIG_IsOK(ecode2)) {
23478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23479 }
23480 arg2 = static_cast< int >(val2);
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23489 return resultobj;
23490 fail:
23491 return NULL;
23492 }
23493
23494
23495 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23496 PyObject *resultobj = 0;
23497 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23498 wxWindow *result = 0 ;
23499 void *argp1 = 0 ;
23500 int res1 = 0 ;
23501 PyObject *swig_obj[1] ;
23502
23503 if (!args) SWIG_fail;
23504 swig_obj[0] = args;
23505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23506 if (!SWIG_IsOK(res1)) {
23507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23508 }
23509 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 {
23517 resultobj = wxPyMake_wxObject(result, (bool)0);
23518 }
23519 return resultobj;
23520 fail:
23521 return NULL;
23522 }
23523
23524
23525 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23526 PyObject *resultobj = 0;
23527 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23528 wxWindow *arg2 = (wxWindow *) 0 ;
23529 void *argp1 = 0 ;
23530 int res1 = 0 ;
23531 void *argp2 = 0 ;
23532 int res2 = 0 ;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char * kwnames[] = {
23536 (char *) "self",(char *) "win", NULL
23537 };
23538
23539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23541 if (!SWIG_IsOK(res1)) {
23542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23543 }
23544 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23546 if (!SWIG_IsOK(res2)) {
23547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23548 }
23549 arg2 = reinterpret_cast< wxWindow * >(argp2);
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 (arg1)->SetWindow(arg2);
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 resultobj = SWIG_Py_Void();
23557 return resultobj;
23558 fail:
23559 return NULL;
23560 }
23561
23562
23563 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23564 PyObject *obj;
23565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23566 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23567 return SWIG_Py_Void();
23568 }
23569
23570 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23571 return SWIG_Python_InitShadowInstance(args);
23572 }
23573
23574 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj = 0;
23576 wxWindow *arg1 = (wxWindow *) NULL ;
23577 wxChildFocusEvent *result = 0 ;
23578 void *argp1 = 0 ;
23579 int res1 = 0 ;
23580 PyObject * obj0 = 0 ;
23581 char * kwnames[] = {
23582 (char *) "win", NULL
23583 };
23584
23585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23586 if (obj0) {
23587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23590 }
23591 arg1 = reinterpret_cast< wxWindow * >(argp1);
23592 }
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23596 wxPyEndAllowThreads(__tstate);
23597 if (PyErr_Occurred()) SWIG_fail;
23598 }
23599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23609 wxWindow *result = 0 ;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 PyObject *swig_obj[1] ;
23613
23614 if (!args) SWIG_fail;
23615 swig_obj[0] = args;
23616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23619 }
23620 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 {
23628 resultobj = wxPyMake_wxObject(result, (bool)0);
23629 }
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23637 PyObject *obj;
23638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23639 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23640 return SWIG_Py_Void();
23641 }
23642
23643 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23644 return SWIG_Python_InitShadowInstance(args);
23645 }
23646
23647 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23648 PyObject *resultobj = 0;
23649 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23650 bool arg2 = (bool) true ;
23651 int arg3 = (int) 0 ;
23652 wxActivateEvent *result = 0 ;
23653 int val1 ;
23654 int ecode1 = 0 ;
23655 bool val2 ;
23656 int ecode2 = 0 ;
23657 int val3 ;
23658 int ecode3 = 0 ;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 PyObject * obj2 = 0 ;
23662 char * kwnames[] = {
23663 (char *) "type",(char *) "active",(char *) "Id", NULL
23664 };
23665
23666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23667 if (obj0) {
23668 ecode1 = SWIG_AsVal_int(obj0, &val1);
23669 if (!SWIG_IsOK(ecode1)) {
23670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23671 }
23672 arg1 = static_cast< wxEventType >(val1);
23673 }
23674 if (obj1) {
23675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23676 if (!SWIG_IsOK(ecode2)) {
23677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23678 }
23679 arg2 = static_cast< bool >(val2);
23680 }
23681 if (obj2) {
23682 ecode3 = SWIG_AsVal_int(obj2, &val3);
23683 if (!SWIG_IsOK(ecode3)) {
23684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23685 }
23686 arg3 = static_cast< int >(val3);
23687 }
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23704 bool result;
23705 void *argp1 = 0 ;
23706 int res1 = 0 ;
23707 PyObject *swig_obj[1] ;
23708
23709 if (!args) SWIG_fail;
23710 swig_obj[0] = args;
23711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23714 }
23715 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 {
23723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 PyObject *obj;
23733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23734 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23735 return SWIG_Py_Void();
23736 }
23737
23738 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23739 return SWIG_Python_InitShadowInstance(args);
23740 }
23741
23742 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 int arg1 = (int) 0 ;
23745 wxInitDialogEvent *result = 0 ;
23746 int val1 ;
23747 int ecode1 = 0 ;
23748 PyObject * obj0 = 0 ;
23749 char * kwnames[] = {
23750 (char *) "Id", NULL
23751 };
23752
23753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23754 if (obj0) {
23755 ecode1 = SWIG_AsVal_int(obj0, &val1);
23756 if (!SWIG_IsOK(ecode1)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23758 }
23759 arg1 = static_cast< int >(val1);
23760 }
23761 {
23762 PyThreadState* __tstate = wxPyBeginAllowThreads();
23763 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23764 wxPyEndAllowThreads(__tstate);
23765 if (PyErr_Occurred()) SWIG_fail;
23766 }
23767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23768 return resultobj;
23769 fail:
23770 return NULL;
23771 }
23772
23773
23774 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23775 PyObject *obj;
23776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23777 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23778 return SWIG_Py_Void();
23779 }
23780
23781 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 return SWIG_Python_InitShadowInstance(args);
23783 }
23784
23785 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj = 0;
23787 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23788 int arg2 = (int) 0 ;
23789 wxMenu *arg3 = (wxMenu *) NULL ;
23790 wxMenuEvent *result = 0 ;
23791 int val1 ;
23792 int ecode1 = 0 ;
23793 int val2 ;
23794 int ecode2 = 0 ;
23795 void *argp3 = 0 ;
23796 int res3 = 0 ;
23797 PyObject * obj0 = 0 ;
23798 PyObject * obj1 = 0 ;
23799 PyObject * obj2 = 0 ;
23800 char * kwnames[] = {
23801 (char *) "type",(char *) "winid",(char *) "menu", NULL
23802 };
23803
23804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23805 if (obj0) {
23806 ecode1 = SWIG_AsVal_int(obj0, &val1);
23807 if (!SWIG_IsOK(ecode1)) {
23808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23809 }
23810 arg1 = static_cast< wxEventType >(val1);
23811 }
23812 if (obj1) {
23813 ecode2 = SWIG_AsVal_int(obj1, &val2);
23814 if (!SWIG_IsOK(ecode2)) {
23815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23816 }
23817 arg2 = static_cast< int >(val2);
23818 }
23819 if (obj2) {
23820 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23821 if (!SWIG_IsOK(res3)) {
23822 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23823 }
23824 arg3 = reinterpret_cast< wxMenu * >(argp3);
23825 }
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23842 int result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_From_int(static_cast< int >(result));
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23870 bool result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 {
23889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23890 }
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23898 PyObject *resultobj = 0;
23899 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23900 wxMenu *result = 0 ;
23901 void *argp1 = 0 ;
23902 int res1 = 0 ;
23903 PyObject *swig_obj[1] ;
23904
23905 if (!args) SWIG_fail;
23906 swig_obj[0] = args;
23907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23908 if (!SWIG_IsOK(res1)) {
23909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23910 }
23911 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23912 {
23913 PyThreadState* __tstate = wxPyBeginAllowThreads();
23914 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 {
23919 resultobj = wxPyMake_wxObject(result, (bool)0);
23920 }
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23928 PyObject *obj;
23929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23930 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23931 return SWIG_Py_Void();
23932 }
23933
23934 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 return SWIG_Python_InitShadowInstance(args);
23936 }
23937
23938 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23939 PyObject *resultobj = 0;
23940 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23941 int arg2 = (int) 0 ;
23942 wxCloseEvent *result = 0 ;
23943 int val1 ;
23944 int ecode1 = 0 ;
23945 int val2 ;
23946 int ecode2 = 0 ;
23947 PyObject * obj0 = 0 ;
23948 PyObject * obj1 = 0 ;
23949 char * kwnames[] = {
23950 (char *) "type",(char *) "winid", NULL
23951 };
23952
23953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23954 if (obj0) {
23955 ecode1 = SWIG_AsVal_int(obj0, &val1);
23956 if (!SWIG_IsOK(ecode1)) {
23957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23958 }
23959 arg1 = static_cast< wxEventType >(val1);
23960 }
23961 if (obj1) {
23962 ecode2 = SWIG_AsVal_int(obj1, &val2);
23963 if (!SWIG_IsOK(ecode2)) {
23964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23965 }
23966 arg2 = static_cast< int >(val2);
23967 }
23968 {
23969 PyThreadState* __tstate = wxPyBeginAllowThreads();
23970 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23971 wxPyEndAllowThreads(__tstate);
23972 if (PyErr_Occurred()) SWIG_fail;
23973 }
23974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23975 return resultobj;
23976 fail:
23977 return NULL;
23978 }
23979
23980
23981 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23982 PyObject *resultobj = 0;
23983 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23984 bool arg2 ;
23985 void *argp1 = 0 ;
23986 int res1 = 0 ;
23987 bool val2 ;
23988 int ecode2 = 0 ;
23989 PyObject * obj0 = 0 ;
23990 PyObject * obj1 = 0 ;
23991 char * kwnames[] = {
23992 (char *) "self",(char *) "logOff", NULL
23993 };
23994
23995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
23996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
23997 if (!SWIG_IsOK(res1)) {
23998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
23999 }
24000 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24001 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24002 if (!SWIG_IsOK(ecode2)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24004 }
24005 arg2 = static_cast< bool >(val2);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 (arg1)->SetLoggingOff(arg2);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_Py_Void();
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *resultobj = 0;
24021 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24022 bool result;
24023 void *argp1 = 0 ;
24024 int res1 = 0 ;
24025 PyObject *swig_obj[1] ;
24026
24027 if (!args) SWIG_fail;
24028 swig_obj[0] = args;
24029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24032 }
24033 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 {
24041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24042 }
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24050 PyObject *resultobj = 0;
24051 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24052 bool arg2 = (bool) true ;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 bool val2 ;
24056 int ecode2 = 0 ;
24057 PyObject * obj0 = 0 ;
24058 PyObject * obj1 = 0 ;
24059 char * kwnames[] = {
24060 (char *) "self",(char *) "veto", NULL
24061 };
24062
24063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24067 }
24068 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24069 if (obj1) {
24070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24071 if (!SWIG_IsOK(ecode2)) {
24072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24073 }
24074 arg2 = static_cast< bool >(val2);
24075 }
24076 {
24077 PyThreadState* __tstate = wxPyBeginAllowThreads();
24078 (arg1)->Veto(arg2);
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 resultobj = SWIG_Py_Void();
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24090 PyObject *resultobj = 0;
24091 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24092 bool result;
24093 void *argp1 = 0 ;
24094 int res1 = 0 ;
24095 PyObject *swig_obj[1] ;
24096
24097 if (!args) SWIG_fail;
24098 swig_obj[0] = args;
24099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24100 if (!SWIG_IsOK(res1)) {
24101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24102 }
24103 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 {
24111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24112 }
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj = 0;
24121 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24122 bool arg2 ;
24123 void *argp1 = 0 ;
24124 int res1 = 0 ;
24125 bool val2 ;
24126 int ecode2 = 0 ;
24127 PyObject * obj0 = 0 ;
24128 PyObject * obj1 = 0 ;
24129 char * kwnames[] = {
24130 (char *) "self",(char *) "canVeto", NULL
24131 };
24132
24133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24137 }
24138 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24139 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24140 if (!SWIG_IsOK(ecode2)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24142 }
24143 arg2 = static_cast< bool >(val2);
24144 {
24145 PyThreadState* __tstate = wxPyBeginAllowThreads();
24146 (arg1)->SetCanVeto(arg2);
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 resultobj = SWIG_Py_Void();
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *resultobj = 0;
24159 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24160 bool result;
24161 void *argp1 = 0 ;
24162 int res1 = 0 ;
24163 PyObject *swig_obj[1] ;
24164
24165 if (!args) SWIG_fail;
24166 swig_obj[0] = args;
24167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24168 if (!SWIG_IsOK(res1)) {
24169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24170 }
24171 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 {
24179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24180 }
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24188 PyObject *obj;
24189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24190 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24191 return SWIG_Py_Void();
24192 }
24193
24194 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24195 return SWIG_Python_InitShadowInstance(args);
24196 }
24197
24198 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj = 0;
24200 int arg1 = (int) 0 ;
24201 bool arg2 = (bool) false ;
24202 wxShowEvent *result = 0 ;
24203 int val1 ;
24204 int ecode1 = 0 ;
24205 bool val2 ;
24206 int ecode2 = 0 ;
24207 PyObject * obj0 = 0 ;
24208 PyObject * obj1 = 0 ;
24209 char * kwnames[] = {
24210 (char *) "winid",(char *) "show", NULL
24211 };
24212
24213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24214 if (obj0) {
24215 ecode1 = SWIG_AsVal_int(obj0, &val1);
24216 if (!SWIG_IsOK(ecode1)) {
24217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24218 }
24219 arg1 = static_cast< int >(val1);
24220 }
24221 if (obj1) {
24222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24223 if (!SWIG_IsOK(ecode2)) {
24224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24225 }
24226 arg2 = static_cast< bool >(val2);
24227 }
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24235 return resultobj;
24236 fail:
24237 return NULL;
24238 }
24239
24240
24241 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24242 PyObject *resultobj = 0;
24243 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24244 bool arg2 ;
24245 void *argp1 = 0 ;
24246 int res1 = 0 ;
24247 bool val2 ;
24248 int ecode2 = 0 ;
24249 PyObject * obj0 = 0 ;
24250 PyObject * obj1 = 0 ;
24251 char * kwnames[] = {
24252 (char *) "self",(char *) "show", NULL
24253 };
24254
24255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24257 if (!SWIG_IsOK(res1)) {
24258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24259 }
24260 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24262 if (!SWIG_IsOK(ecode2)) {
24263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24264 }
24265 arg2 = static_cast< bool >(val2);
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 (arg1)->SetShow(arg2);
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 resultobj = SWIG_Py_Void();
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24280 PyObject *resultobj = 0;
24281 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24282 bool result;
24283 void *argp1 = 0 ;
24284 int res1 = 0 ;
24285 PyObject *swig_obj[1] ;
24286
24287 if (!args) SWIG_fail;
24288 swig_obj[0] = args;
24289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24290 if (!SWIG_IsOK(res1)) {
24291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24292 }
24293 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24294 {
24295 PyThreadState* __tstate = wxPyBeginAllowThreads();
24296 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24297 wxPyEndAllowThreads(__tstate);
24298 if (PyErr_Occurred()) SWIG_fail;
24299 }
24300 {
24301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24302 }
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *obj;
24311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24312 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24313 return SWIG_Py_Void();
24314 }
24315
24316 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24317 return SWIG_Python_InitShadowInstance(args);
24318 }
24319
24320 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj = 0;
24322 int arg1 = (int) 0 ;
24323 bool arg2 = (bool) true ;
24324 wxIconizeEvent *result = 0 ;
24325 int val1 ;
24326 int ecode1 = 0 ;
24327 bool val2 ;
24328 int ecode2 = 0 ;
24329 PyObject * obj0 = 0 ;
24330 PyObject * obj1 = 0 ;
24331 char * kwnames[] = {
24332 (char *) "id",(char *) "iconized", NULL
24333 };
24334
24335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24336 if (obj0) {
24337 ecode1 = SWIG_AsVal_int(obj0, &val1);
24338 if (!SWIG_IsOK(ecode1)) {
24339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24340 }
24341 arg1 = static_cast< int >(val1);
24342 }
24343 if (obj1) {
24344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24345 if (!SWIG_IsOK(ecode2)) {
24346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24347 }
24348 arg2 = static_cast< bool >(val2);
24349 }
24350 {
24351 PyThreadState* __tstate = wxPyBeginAllowThreads();
24352 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24364 PyObject *resultobj = 0;
24365 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24366 bool result;
24367 void *argp1 = 0 ;
24368 int res1 = 0 ;
24369 PyObject *swig_obj[1] ;
24370
24371 if (!args) SWIG_fail;
24372 swig_obj[0] = args;
24373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24374 if (!SWIG_IsOK(res1)) {
24375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24376 }
24377 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 result = (bool)(arg1)->Iconized();
24381 wxPyEndAllowThreads(__tstate);
24382 if (PyErr_Occurred()) SWIG_fail;
24383 }
24384 {
24385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24386 }
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 PyObject *obj;
24395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24396 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24397 return SWIG_Py_Void();
24398 }
24399
24400 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24401 return SWIG_Python_InitShadowInstance(args);
24402 }
24403
24404 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24405 PyObject *resultobj = 0;
24406 int arg1 = (int) 0 ;
24407 wxMaximizeEvent *result = 0 ;
24408 int val1 ;
24409 int ecode1 = 0 ;
24410 PyObject * obj0 = 0 ;
24411 char * kwnames[] = {
24412 (char *) "id", NULL
24413 };
24414
24415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24416 if (obj0) {
24417 ecode1 = SWIG_AsVal_int(obj0, &val1);
24418 if (!SWIG_IsOK(ecode1)) {
24419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24420 }
24421 arg1 = static_cast< int >(val1);
24422 }
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24437 PyObject *obj;
24438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24440 return SWIG_Py_Void();
24441 }
24442
24443 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24444 return SWIG_Python_InitShadowInstance(args);
24445 }
24446
24447 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24448 PyObject *resultobj = 0;
24449 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24450 wxPoint result;
24451 void *argp1 = 0 ;
24452 int res1 = 0 ;
24453 PyObject *swig_obj[1] ;
24454
24455 if (!args) SWIG_fail;
24456 swig_obj[0] = args;
24457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24458 if (!SWIG_IsOK(res1)) {
24459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24460 }
24461 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 result = (arg1)->GetPosition();
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24478 int result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 result = (int)(arg1)->GetNumberOfFiles();
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_From_int(static_cast< int >(result));
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *resultobj = 0;
24505 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24506 PyObject *result = 0 ;
24507 void *argp1 = 0 ;
24508 int res1 = 0 ;
24509 PyObject *swig_obj[1] ;
24510
24511 if (!args) SWIG_fail;
24512 swig_obj[0] = args;
24513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24514 if (!SWIG_IsOK(res1)) {
24515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24516 }
24517 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = result;
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *obj;
24533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24534 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24535 return SWIG_Py_Void();
24536 }
24537
24538 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj = 0;
24540 int arg1 = (int) 0 ;
24541 wxUpdateUIEvent *result = 0 ;
24542 int val1 ;
24543 int ecode1 = 0 ;
24544 PyObject * obj0 = 0 ;
24545 char * kwnames[] = {
24546 (char *) "commandId", NULL
24547 };
24548
24549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24550 if (obj0) {
24551 ecode1 = SWIG_AsVal_int(obj0, &val1);
24552 if (!SWIG_IsOK(ecode1)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24554 }
24555 arg1 = static_cast< int >(val1);
24556 }
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24571 PyObject *resultobj = 0;
24572 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24573 bool result;
24574 void *argp1 = 0 ;
24575 int res1 = 0 ;
24576 PyObject *swig_obj[1] ;
24577
24578 if (!args) SWIG_fail;
24579 swig_obj[0] = args;
24580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24581 if (!SWIG_IsOK(res1)) {
24582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24583 }
24584 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 {
24592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24593 }
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24601 PyObject *resultobj = 0;
24602 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24603 bool result;
24604 void *argp1 = 0 ;
24605 int res1 = 0 ;
24606 PyObject *swig_obj[1] ;
24607
24608 if (!args) SWIG_fail;
24609 swig_obj[0] = args;
24610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24611 if (!SWIG_IsOK(res1)) {
24612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24613 }
24614 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 {
24622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24623 }
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *resultobj = 0;
24632 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24633 bool result;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 PyObject *swig_obj[1] ;
24637
24638 if (!args) SWIG_fail;
24639 swig_obj[0] = args;
24640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24641 if (!SWIG_IsOK(res1)) {
24642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24643 }
24644 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 {
24652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24653 }
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24661 PyObject *resultobj = 0;
24662 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24663 wxString result;
24664 void *argp1 = 0 ;
24665 int res1 = 0 ;
24666 PyObject *swig_obj[1] ;
24667
24668 if (!args) SWIG_fail;
24669 swig_obj[0] = args;
24670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24671 if (!SWIG_IsOK(res1)) {
24672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24673 }
24674 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 #if wxUSE_UNICODE
24683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24684 #else
24685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24686 #endif
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 PyObject *resultobj = 0;
24696 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24697 bool result;
24698 void *argp1 = 0 ;
24699 int res1 = 0 ;
24700 PyObject *swig_obj[1] ;
24701
24702 if (!args) SWIG_fail;
24703 swig_obj[0] = args;
24704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24707 }
24708 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24727 bool result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24737 }
24738 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24757 bool result;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 {
24776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24777 }
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24785 PyObject *resultobj = 0;
24786 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24787 bool result;
24788 void *argp1 = 0 ;
24789 int res1 = 0 ;
24790 PyObject *swig_obj[1] ;
24791
24792 if (!args) SWIG_fail;
24793 swig_obj[0] = args;
24794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24795 if (!SWIG_IsOK(res1)) {
24796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24797 }
24798 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 {
24806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24807 }
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24817 bool arg2 ;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 bool val2 ;
24821 int ecode2 = 0 ;
24822 PyObject * obj0 = 0 ;
24823 PyObject * obj1 = 0 ;
24824 char * kwnames[] = {
24825 (char *) "self",(char *) "check", NULL
24826 };
24827
24828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24830 if (!SWIG_IsOK(res1)) {
24831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24832 }
24833 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24835 if (!SWIG_IsOK(ecode2)) {
24836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24837 }
24838 arg2 = static_cast< bool >(val2);
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 (arg1)->Check(arg2);
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 resultobj = SWIG_Py_Void();
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj = 0;
24854 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24855 bool arg2 ;
24856 void *argp1 = 0 ;
24857 int res1 = 0 ;
24858 bool val2 ;
24859 int ecode2 = 0 ;
24860 PyObject * obj0 = 0 ;
24861 PyObject * obj1 = 0 ;
24862 char * kwnames[] = {
24863 (char *) "self",(char *) "enable", NULL
24864 };
24865
24866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24868 if (!SWIG_IsOK(res1)) {
24869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24870 }
24871 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24873 if (!SWIG_IsOK(ecode2)) {
24874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24875 }
24876 arg2 = static_cast< bool >(val2);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 (arg1)->Enable(arg2);
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 resultobj = SWIG_Py_Void();
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24891 PyObject *resultobj = 0;
24892 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24893 bool arg2 ;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 bool val2 ;
24897 int ecode2 = 0 ;
24898 PyObject * obj0 = 0 ;
24899 PyObject * obj1 = 0 ;
24900 char * kwnames[] = {
24901 (char *) "self",(char *) "show", NULL
24902 };
24903
24904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24908 }
24909 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24911 if (!SWIG_IsOK(ecode2)) {
24912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24913 }
24914 arg2 = static_cast< bool >(val2);
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 (arg1)->Show(arg2);
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 resultobj = SWIG_Py_Void();
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24931 wxString *arg2 = 0 ;
24932 void *argp1 = 0 ;
24933 int res1 = 0 ;
24934 bool temp2 = false ;
24935 PyObject * obj0 = 0 ;
24936 PyObject * obj1 = 0 ;
24937 char * kwnames[] = {
24938 (char *) "self",(char *) "text", NULL
24939 };
24940
24941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24943 if (!SWIG_IsOK(res1)) {
24944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24945 }
24946 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24947 {
24948 arg2 = wxString_in_helper(obj1);
24949 if (arg2 == NULL) SWIG_fail;
24950 temp2 = true;
24951 }
24952 {
24953 PyThreadState* __tstate = wxPyBeginAllowThreads();
24954 (arg1)->SetText((wxString const &)*arg2);
24955 wxPyEndAllowThreads(__tstate);
24956 if (PyErr_Occurred()) SWIG_fail;
24957 }
24958 resultobj = SWIG_Py_Void();
24959 {
24960 if (temp2)
24961 delete arg2;
24962 }
24963 return resultobj;
24964 fail:
24965 {
24966 if (temp2)
24967 delete arg2;
24968 }
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj = 0;
24975 long arg1 ;
24976 long val1 ;
24977 int ecode1 = 0 ;
24978 PyObject * obj0 = 0 ;
24979 char * kwnames[] = {
24980 (char *) "updateInterval", NULL
24981 };
24982
24983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24984 ecode1 = SWIG_AsVal_long(obj0, &val1);
24985 if (!SWIG_IsOK(ecode1)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24987 }
24988 arg1 = static_cast< long >(val1);
24989 {
24990 PyThreadState* __tstate = wxPyBeginAllowThreads();
24991 wxUpdateUIEvent::SetUpdateInterval(arg1);
24992 wxPyEndAllowThreads(__tstate);
24993 if (PyErr_Occurred()) SWIG_fail;
24994 }
24995 resultobj = SWIG_Py_Void();
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25003 PyObject *resultobj = 0;
25004 long result;
25005
25006 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25007 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25010 wxPyEndAllowThreads(__tstate);
25011 if (PyErr_Occurred()) SWIG_fail;
25012 }
25013 resultobj = SWIG_From_long(static_cast< long >(result));
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = 0;
25022 wxWindow *arg1 = (wxWindow *) 0 ;
25023 bool result;
25024 void *argp1 = 0 ;
25025 int res1 = 0 ;
25026 PyObject * obj0 = 0 ;
25027 char * kwnames[] = {
25028 (char *) "win", NULL
25029 };
25030
25031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25033 if (!SWIG_IsOK(res1)) {
25034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25035 }
25036 arg1 = reinterpret_cast< wxWindow * >(argp1);
25037 {
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 {
25044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25045 }
25046 return resultobj;
25047 fail:
25048 return NULL;
25049 }
25050
25051
25052 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25053 PyObject *resultobj = 0;
25054
25055 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25056 {
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 wxUpdateUIEvent::ResetUpdateTime();
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 resultobj = SWIG_Py_Void();
25063 return resultobj;
25064 fail:
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj = 0;
25071 wxUpdateUIMode arg1 ;
25072 int val1 ;
25073 int ecode1 = 0 ;
25074 PyObject * obj0 = 0 ;
25075 char * kwnames[] = {
25076 (char *) "mode", NULL
25077 };
25078
25079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25080 ecode1 = SWIG_AsVal_int(obj0, &val1);
25081 if (!SWIG_IsOK(ecode1)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25083 }
25084 arg1 = static_cast< wxUpdateUIMode >(val1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 wxUpdateUIEvent::SetMode(arg1);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 wxUpdateUIMode result;
25101
25102 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25103 {
25104 PyThreadState* __tstate = wxPyBeginAllowThreads();
25105 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 resultobj = SWIG_From_int(static_cast< int >(result));
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25117 PyObject *obj;
25118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25119 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25120 return SWIG_Py_Void();
25121 }
25122
25123 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25124 return SWIG_Python_InitShadowInstance(args);
25125 }
25126
25127 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25128 PyObject *resultobj = 0;
25129 wxSysColourChangedEvent *result = 0 ;
25130
25131 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25132 {
25133 PyThreadState* __tstate = wxPyBeginAllowThreads();
25134 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25139 return resultobj;
25140 fail:
25141 return NULL;
25142 }
25143
25144
25145 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25146 PyObject *obj;
25147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25148 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25149 return SWIG_Py_Void();
25150 }
25151
25152 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25153 return SWIG_Python_InitShadowInstance(args);
25154 }
25155
25156 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25157 PyObject *resultobj = 0;
25158 int arg1 = (int) 0 ;
25159 wxWindow *arg2 = (wxWindow *) NULL ;
25160 wxMouseCaptureChangedEvent *result = 0 ;
25161 int val1 ;
25162 int ecode1 = 0 ;
25163 void *argp2 = 0 ;
25164 int res2 = 0 ;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "winid",(char *) "gainedCapture", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25172 if (obj0) {
25173 ecode1 = SWIG_AsVal_int(obj0, &val1);
25174 if (!SWIG_IsOK(ecode1)) {
25175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25176 }
25177 arg1 = static_cast< int >(val1);
25178 }
25179 if (obj1) {
25180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25181 if (!SWIG_IsOK(res2)) {
25182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25183 }
25184 arg2 = reinterpret_cast< wxWindow * >(argp2);
25185 }
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 PyObject *resultobj = 0;
25201 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25202 wxWindow *result = 0 ;
25203 void *argp1 = 0 ;
25204 int res1 = 0 ;
25205 PyObject *swig_obj[1] ;
25206
25207 if (!args) SWIG_fail;
25208 swig_obj[0] = args;
25209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25210 if (!SWIG_IsOK(res1)) {
25211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25212 }
25213 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 {
25221 resultobj = wxPyMake_wxObject(result, (bool)0);
25222 }
25223 return resultobj;
25224 fail:
25225 return NULL;
25226 }
25227
25228
25229 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25230 PyObject *obj;
25231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25232 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25233 return SWIG_Py_Void();
25234 }
25235
25236 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25237 return SWIG_Python_InitShadowInstance(args);
25238 }
25239
25240 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *resultobj = 0;
25242 wxDisplayChangedEvent *result = 0 ;
25243
25244 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25252 return resultobj;
25253 fail:
25254 return NULL;
25255 }
25256
25257
25258 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25259 PyObject *obj;
25260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25261 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25262 return SWIG_Py_Void();
25263 }
25264
25265 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25266 return SWIG_Python_InitShadowInstance(args);
25267 }
25268
25269 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25270 PyObject *resultobj = 0;
25271 int arg1 = (int) 0 ;
25272 wxPaletteChangedEvent *result = 0 ;
25273 int val1 ;
25274 int ecode1 = 0 ;
25275 PyObject * obj0 = 0 ;
25276 char * kwnames[] = {
25277 (char *) "id", NULL
25278 };
25279
25280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25281 if (obj0) {
25282 ecode1 = SWIG_AsVal_int(obj0, &val1);
25283 if (!SWIG_IsOK(ecode1)) {
25284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25285 }
25286 arg1 = static_cast< int >(val1);
25287 }
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj = 0;
25303 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25304 wxWindow *arg2 = (wxWindow *) 0 ;
25305 void *argp1 = 0 ;
25306 int res1 = 0 ;
25307 void *argp2 = 0 ;
25308 int res2 = 0 ;
25309 PyObject * obj0 = 0 ;
25310 PyObject * obj1 = 0 ;
25311 char * kwnames[] = {
25312 (char *) "self",(char *) "win", NULL
25313 };
25314
25315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25317 if (!SWIG_IsOK(res1)) {
25318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25319 }
25320 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25322 if (!SWIG_IsOK(res2)) {
25323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25324 }
25325 arg2 = reinterpret_cast< wxWindow * >(argp2);
25326 {
25327 PyThreadState* __tstate = wxPyBeginAllowThreads();
25328 (arg1)->SetChangedWindow(arg2);
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 resultobj = SWIG_Py_Void();
25333 return resultobj;
25334 fail:
25335 return NULL;
25336 }
25337
25338
25339 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25340 PyObject *resultobj = 0;
25341 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25342 wxWindow *result = 0 ;
25343 void *argp1 = 0 ;
25344 int res1 = 0 ;
25345 PyObject *swig_obj[1] ;
25346
25347 if (!args) SWIG_fail;
25348 swig_obj[0] = args;
25349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25350 if (!SWIG_IsOK(res1)) {
25351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25352 }
25353 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 result = (wxWindow *)(arg1)->GetChangedWindow();
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 {
25361 resultobj = wxPyMake_wxObject(result, (bool)0);
25362 }
25363 return resultobj;
25364 fail:
25365 return NULL;
25366 }
25367
25368
25369 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25370 PyObject *obj;
25371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25372 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25373 return SWIG_Py_Void();
25374 }
25375
25376 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25377 return SWIG_Python_InitShadowInstance(args);
25378 }
25379
25380 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25381 PyObject *resultobj = 0;
25382 int arg1 = (int) 0 ;
25383 wxQueryNewPaletteEvent *result = 0 ;
25384 int val1 ;
25385 int ecode1 = 0 ;
25386 PyObject * obj0 = 0 ;
25387 char * kwnames[] = {
25388 (char *) "winid", NULL
25389 };
25390
25391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25392 if (obj0) {
25393 ecode1 = SWIG_AsVal_int(obj0, &val1);
25394 if (!SWIG_IsOK(ecode1)) {
25395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25396 }
25397 arg1 = static_cast< int >(val1);
25398 }
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj = 0;
25414 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25415 bool arg2 ;
25416 void *argp1 = 0 ;
25417 int res1 = 0 ;
25418 bool val2 ;
25419 int ecode2 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 PyObject * obj1 = 0 ;
25422 char * kwnames[] = {
25423 (char *) "self",(char *) "realized", NULL
25424 };
25425
25426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25428 if (!SWIG_IsOK(res1)) {
25429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25430 }
25431 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25432 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25433 if (!SWIG_IsOK(ecode2)) {
25434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25435 }
25436 arg2 = static_cast< bool >(val2);
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 (arg1)->SetPaletteRealized(arg2);
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 resultobj = SWIG_Py_Void();
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25451 PyObject *resultobj = 0;
25452 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25453 bool result;
25454 void *argp1 = 0 ;
25455 int res1 = 0 ;
25456 PyObject *swig_obj[1] ;
25457
25458 if (!args) SWIG_fail;
25459 swig_obj[0] = args;
25460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25463 }
25464 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25468 wxPyEndAllowThreads(__tstate);
25469 if (PyErr_Occurred()) SWIG_fail;
25470 }
25471 {
25472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25473 }
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 PyObject *obj;
25482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25483 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25484 return SWIG_Py_Void();
25485 }
25486
25487 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 return SWIG_Python_InitShadowInstance(args);
25489 }
25490
25491 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25492 PyObject *resultobj = 0;
25493 wxNavigationKeyEvent *result = 0 ;
25494
25495 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25496 {
25497 PyThreadState* __tstate = wxPyBeginAllowThreads();
25498 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25503 return resultobj;
25504 fail:
25505 return NULL;
25506 }
25507
25508
25509 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 PyObject *resultobj = 0;
25511 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25512 bool result;
25513 void *argp1 = 0 ;
25514 int res1 = 0 ;
25515 PyObject *swig_obj[1] ;
25516
25517 if (!args) SWIG_fail;
25518 swig_obj[0] = args;
25519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25520 if (!SWIG_IsOK(res1)) {
25521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25522 }
25523 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25527 wxPyEndAllowThreads(__tstate);
25528 if (PyErr_Occurred()) SWIG_fail;
25529 }
25530 {
25531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25532 }
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj = 0;
25541 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25542 bool arg2 ;
25543 void *argp1 = 0 ;
25544 int res1 = 0 ;
25545 bool val2 ;
25546 int ecode2 = 0 ;
25547 PyObject * obj0 = 0 ;
25548 PyObject * obj1 = 0 ;
25549 char * kwnames[] = {
25550 (char *) "self",(char *) "forward", NULL
25551 };
25552
25553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25555 if (!SWIG_IsOK(res1)) {
25556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25557 }
25558 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25560 if (!SWIG_IsOK(ecode2)) {
25561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25562 }
25563 arg2 = static_cast< bool >(val2);
25564 {
25565 PyThreadState* __tstate = wxPyBeginAllowThreads();
25566 (arg1)->SetDirection(arg2);
25567 wxPyEndAllowThreads(__tstate);
25568 if (PyErr_Occurred()) SWIG_fail;
25569 }
25570 resultobj = SWIG_Py_Void();
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25578 PyObject *resultobj = 0;
25579 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25580 bool result;
25581 void *argp1 = 0 ;
25582 int res1 = 0 ;
25583 PyObject *swig_obj[1] ;
25584
25585 if (!args) SWIG_fail;
25586 swig_obj[0] = args;
25587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25588 if (!SWIG_IsOK(res1)) {
25589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25590 }
25591 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 {
25599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25600 }
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25608 PyObject *resultobj = 0;
25609 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25610 bool arg2 ;
25611 void *argp1 = 0 ;
25612 int res1 = 0 ;
25613 bool val2 ;
25614 int ecode2 = 0 ;
25615 PyObject * obj0 = 0 ;
25616 PyObject * obj1 = 0 ;
25617 char * kwnames[] = {
25618 (char *) "self",(char *) "ischange", NULL
25619 };
25620
25621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25623 if (!SWIG_IsOK(res1)) {
25624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25625 }
25626 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25627 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25628 if (!SWIG_IsOK(ecode2)) {
25629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25630 }
25631 arg2 = static_cast< bool >(val2);
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 (arg1)->SetWindowChange(arg2);
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 resultobj = SWIG_Py_Void();
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25648 bool result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 PyObject *swig_obj[1] ;
25652
25653 if (!args) SWIG_fail;
25654 swig_obj[0] = args;
25655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25658 }
25659 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 {
25667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25676 PyObject *resultobj = 0;
25677 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25678 bool arg2 ;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 bool val2 ;
25682 int ecode2 = 0 ;
25683 PyObject * obj0 = 0 ;
25684 PyObject * obj1 = 0 ;
25685 char * kwnames[] = {
25686 (char *) "self",(char *) "bIs", NULL
25687 };
25688
25689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25691 if (!SWIG_IsOK(res1)) {
25692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25693 }
25694 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25696 if (!SWIG_IsOK(ecode2)) {
25697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25698 }
25699 arg2 = static_cast< bool >(val2);
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 (arg1)->SetFromTab(arg2);
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_Py_Void();
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj = 0;
25715 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25716 long arg2 ;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 long val2 ;
25720 int ecode2 = 0 ;
25721 PyObject * obj0 = 0 ;
25722 PyObject * obj1 = 0 ;
25723 char * kwnames[] = {
25724 (char *) "self",(char *) "flags", NULL
25725 };
25726
25727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25731 }
25732 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25733 ecode2 = SWIG_AsVal_long(obj1, &val2);
25734 if (!SWIG_IsOK(ecode2)) {
25735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25736 }
25737 arg2 = static_cast< long >(val2);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 (arg1)->SetFlags(arg2);
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 resultobj = SWIG_Py_Void();
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25752 PyObject *resultobj = 0;
25753 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25754 wxWindow *result = 0 ;
25755 void *argp1 = 0 ;
25756 int res1 = 0 ;
25757 PyObject *swig_obj[1] ;
25758
25759 if (!args) SWIG_fail;
25760 swig_obj[0] = args;
25761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25762 if (!SWIG_IsOK(res1)) {
25763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25764 }
25765 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 {
25773 resultobj = wxPyMake_wxObject(result, (bool)0);
25774 }
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj = 0;
25783 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25784 wxWindow *arg2 = (wxWindow *) 0 ;
25785 void *argp1 = 0 ;
25786 int res1 = 0 ;
25787 void *argp2 = 0 ;
25788 int res2 = 0 ;
25789 PyObject * obj0 = 0 ;
25790 PyObject * obj1 = 0 ;
25791 char * kwnames[] = {
25792 (char *) "self",(char *) "win", NULL
25793 };
25794
25795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25799 }
25800 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25802 if (!SWIG_IsOK(res2)) {
25803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25804 }
25805 arg2 = reinterpret_cast< wxWindow * >(argp2);
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 (arg1)->SetCurrentFocus(arg2);
25809 wxPyEndAllowThreads(__tstate);
25810 if (PyErr_Occurred()) SWIG_fail;
25811 }
25812 resultobj = SWIG_Py_Void();
25813 return resultobj;
25814 fail:
25815 return NULL;
25816 }
25817
25818
25819 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25820 PyObject *obj;
25821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25822 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25823 return SWIG_Py_Void();
25824 }
25825
25826 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25827 return SWIG_Python_InitShadowInstance(args);
25828 }
25829
25830 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25831 PyObject *resultobj = 0;
25832 wxWindow *arg1 = (wxWindow *) NULL ;
25833 wxWindowCreateEvent *result = 0 ;
25834 void *argp1 = 0 ;
25835 int res1 = 0 ;
25836 PyObject * obj0 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "win", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25842 if (obj0) {
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25846 }
25847 arg1 = reinterpret_cast< wxWindow * >(argp1);
25848 }
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25856 return resultobj;
25857 fail:
25858 return NULL;
25859 }
25860
25861
25862 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25863 PyObject *resultobj = 0;
25864 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25865 wxWindow *result = 0 ;
25866 void *argp1 = 0 ;
25867 int res1 = 0 ;
25868 PyObject *swig_obj[1] ;
25869
25870 if (!args) SWIG_fail;
25871 swig_obj[0] = args;
25872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25873 if (!SWIG_IsOK(res1)) {
25874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25875 }
25876 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 {
25884 resultobj = wxPyMake_wxObject(result, (bool)0);
25885 }
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25893 PyObject *obj;
25894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25895 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25896 return SWIG_Py_Void();
25897 }
25898
25899 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25900 return SWIG_Python_InitShadowInstance(args);
25901 }
25902
25903 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25904 PyObject *resultobj = 0;
25905 wxWindow *arg1 = (wxWindow *) NULL ;
25906 wxWindowDestroyEvent *result = 0 ;
25907 void *argp1 = 0 ;
25908 int res1 = 0 ;
25909 PyObject * obj0 = 0 ;
25910 char * kwnames[] = {
25911 (char *) "win", NULL
25912 };
25913
25914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25915 if (obj0) {
25916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25917 if (!SWIG_IsOK(res1)) {
25918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25919 }
25920 arg1 = reinterpret_cast< wxWindow * >(argp1);
25921 }
25922 {
25923 PyThreadState* __tstate = wxPyBeginAllowThreads();
25924 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25938 wxWindow *result = 0 ;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 PyObject *swig_obj[1] ;
25942
25943 if (!args) SWIG_fail;
25944 swig_obj[0] = args;
25945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25948 }
25949 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 resultobj = wxPyMake_wxObject(result, (bool)0);
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25966 PyObject *obj;
25967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25968 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25969 return SWIG_Py_Void();
25970 }
25971
25972 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 return SWIG_Python_InitShadowInstance(args);
25974 }
25975
25976 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25977 PyObject *resultobj = 0;
25978 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25979 int arg2 = (int) 0 ;
25980 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25981 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25982 wxContextMenuEvent *result = 0 ;
25983 int val1 ;
25984 int ecode1 = 0 ;
25985 int val2 ;
25986 int ecode2 = 0 ;
25987 wxPoint temp3 ;
25988 PyObject * obj0 = 0 ;
25989 PyObject * obj1 = 0 ;
25990 PyObject * obj2 = 0 ;
25991 char * kwnames[] = {
25992 (char *) "type",(char *) "winid",(char *) "pt", NULL
25993 };
25994
25995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25996 if (obj0) {
25997 ecode1 = SWIG_AsVal_int(obj0, &val1);
25998 if (!SWIG_IsOK(ecode1)) {
25999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26000 }
26001 arg1 = static_cast< wxEventType >(val1);
26002 }
26003 if (obj1) {
26004 ecode2 = SWIG_AsVal_int(obj1, &val2);
26005 if (!SWIG_IsOK(ecode2)) {
26006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26007 }
26008 arg2 = static_cast< int >(val2);
26009 }
26010 if (obj2) {
26011 {
26012 arg3 = &temp3;
26013 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26014 }
26015 }
26016 {
26017 PyThreadState* __tstate = wxPyBeginAllowThreads();
26018 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26030 PyObject *resultobj = 0;
26031 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26032 wxPoint *result = 0 ;
26033 void *argp1 = 0 ;
26034 int res1 = 0 ;
26035 PyObject *swig_obj[1] ;
26036
26037 if (!args) SWIG_fail;
26038 swig_obj[0] = args;
26039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26042 }
26043 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 {
26047 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26048 result = (wxPoint *) &_result_ref;
26049 }
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj = 0;
26062 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26063 wxPoint *arg2 = 0 ;
26064 void *argp1 = 0 ;
26065 int res1 = 0 ;
26066 wxPoint temp2 ;
26067 PyObject * obj0 = 0 ;
26068 PyObject * obj1 = 0 ;
26069 char * kwnames[] = {
26070 (char *) "self",(char *) "pos", NULL
26071 };
26072
26073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26075 if (!SWIG_IsOK(res1)) {
26076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26077 }
26078 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26079 {
26080 arg2 = &temp2;
26081 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 (arg1)->SetPosition((wxPoint const &)*arg2);
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 resultobj = SWIG_Py_Void();
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26097 PyObject *obj;
26098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26099 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26100 return SWIG_Py_Void();
26101 }
26102
26103 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26104 return SWIG_Python_InitShadowInstance(args);
26105 }
26106
26107 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxIdleEvent *result = 0 ;
26110
26111 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (wxIdleEvent *)new wxIdleEvent();
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj = 0;
26127 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26128 bool arg2 = (bool) true ;
26129 void *argp1 = 0 ;
26130 int res1 = 0 ;
26131 bool val2 ;
26132 int ecode2 = 0 ;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char * kwnames[] = {
26136 (char *) "self",(char *) "needMore", NULL
26137 };
26138
26139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26143 }
26144 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26145 if (obj1) {
26146 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26147 if (!SWIG_IsOK(ecode2)) {
26148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26149 }
26150 arg2 = static_cast< bool >(val2);
26151 }
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 (arg1)->RequestMore(arg2);
26155 wxPyEndAllowThreads(__tstate);
26156 if (PyErr_Occurred()) SWIG_fail;
26157 }
26158 resultobj = SWIG_Py_Void();
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 PyObject *resultobj = 0;
26167 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26168 bool result;
26169 void *argp1 = 0 ;
26170 int res1 = 0 ;
26171 PyObject *swig_obj[1] ;
26172
26173 if (!args) SWIG_fail;
26174 swig_obj[0] = args;
26175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26176 if (!SWIG_IsOK(res1)) {
26177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26178 }
26179 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26180 {
26181 PyThreadState* __tstate = wxPyBeginAllowThreads();
26182 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26183 wxPyEndAllowThreads(__tstate);
26184 if (PyErr_Occurred()) SWIG_fail;
26185 }
26186 {
26187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26188 }
26189 return resultobj;
26190 fail:
26191 return NULL;
26192 }
26193
26194
26195 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26196 PyObject *resultobj = 0;
26197 wxIdleMode arg1 ;
26198 int val1 ;
26199 int ecode1 = 0 ;
26200 PyObject * obj0 = 0 ;
26201 char * kwnames[] = {
26202 (char *) "mode", NULL
26203 };
26204
26205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26206 ecode1 = SWIG_AsVal_int(obj0, &val1);
26207 if (!SWIG_IsOK(ecode1)) {
26208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26209 }
26210 arg1 = static_cast< wxIdleMode >(val1);
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 wxIdleEvent::SetMode(arg1);
26214 wxPyEndAllowThreads(__tstate);
26215 if (PyErr_Occurred()) SWIG_fail;
26216 }
26217 resultobj = SWIG_Py_Void();
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26225 PyObject *resultobj = 0;
26226 wxIdleMode result;
26227
26228 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 result = (wxIdleMode)wxIdleEvent::GetMode();
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_From_int(static_cast< int >(result));
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = 0;
26244 wxWindow *arg1 = (wxWindow *) 0 ;
26245 bool result;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject * obj0 = 0 ;
26249 char * kwnames[] = {
26250 (char *) "win", NULL
26251 };
26252
26253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26255 if (!SWIG_IsOK(res1)) {
26256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26257 }
26258 arg1 = reinterpret_cast< wxWindow * >(argp1);
26259 {
26260 PyThreadState* __tstate = wxPyBeginAllowThreads();
26261 result = (bool)wxIdleEvent::CanSend(arg1);
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 {
26266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26267 }
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *obj;
26276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26277 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26278 return SWIG_Py_Void();
26279 }
26280
26281 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 return SWIG_Python_InitShadowInstance(args);
26283 }
26284
26285 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj = 0;
26287 int arg1 = (int) 0 ;
26288 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26289 wxPyEvent *result = 0 ;
26290 int val1 ;
26291 int ecode1 = 0 ;
26292 int val2 ;
26293 int ecode2 = 0 ;
26294 PyObject * obj0 = 0 ;
26295 PyObject * obj1 = 0 ;
26296 char * kwnames[] = {
26297 (char *) "winid",(char *) "eventType", NULL
26298 };
26299
26300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26301 if (obj0) {
26302 ecode1 = SWIG_AsVal_int(obj0, &val1);
26303 if (!SWIG_IsOK(ecode1)) {
26304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26305 }
26306 arg1 = static_cast< int >(val1);
26307 }
26308 if (obj1) {
26309 ecode2 = SWIG_AsVal_int(obj1, &val2);
26310 if (!SWIG_IsOK(ecode2)) {
26311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26312 }
26313 arg2 = static_cast< wxEventType >(val2);
26314 }
26315 {
26316 PyThreadState* __tstate = wxPyBeginAllowThreads();
26317 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26322 return resultobj;
26323 fail:
26324 return NULL;
26325 }
26326
26327
26328 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26329 PyObject *resultobj = 0;
26330 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 PyObject *swig_obj[1] ;
26334
26335 if (!args) SWIG_fail;
26336 swig_obj[0] = args;
26337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26338 if (!SWIG_IsOK(res1)) {
26339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26340 }
26341 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 delete arg1;
26345
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 resultobj = SWIG_Py_Void();
26350 return resultobj;
26351 fail:
26352 return NULL;
26353 }
26354
26355
26356 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26357 PyObject *resultobj = 0;
26358 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26359 PyObject *arg2 = (PyObject *) 0 ;
26360 void *argp1 = 0 ;
26361 int res1 = 0 ;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char * kwnames[] = {
26365 (char *) "self",(char *) "self", NULL
26366 };
26367
26368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26370 if (!SWIG_IsOK(res1)) {
26371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26372 }
26373 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26374 arg2 = obj1;
26375 {
26376 PyThreadState* __tstate = wxPyBeginAllowThreads();
26377 (arg1)->SetSelf(arg2);
26378 wxPyEndAllowThreads(__tstate);
26379 if (PyErr_Occurred()) SWIG_fail;
26380 }
26381 resultobj = SWIG_Py_Void();
26382 return resultobj;
26383 fail:
26384 return NULL;
26385 }
26386
26387
26388 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26389 PyObject *resultobj = 0;
26390 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26391 PyObject *result = 0 ;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 PyObject *swig_obj[1] ;
26395
26396 if (!args) SWIG_fail;
26397 swig_obj[0] = args;
26398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26399 if (!SWIG_IsOK(res1)) {
26400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26401 }
26402 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 result = (PyObject *)(arg1)->GetSelf();
26406 wxPyEndAllowThreads(__tstate);
26407 if (PyErr_Occurred()) SWIG_fail;
26408 }
26409 resultobj = result;
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26417 PyObject *obj;
26418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26419 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26420 return SWIG_Py_Void();
26421 }
26422
26423 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26424 return SWIG_Python_InitShadowInstance(args);
26425 }
26426
26427 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj = 0;
26429 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26430 int arg2 = (int) 0 ;
26431 wxPyCommandEvent *result = 0 ;
26432 int val1 ;
26433 int ecode1 = 0 ;
26434 int val2 ;
26435 int ecode2 = 0 ;
26436 PyObject * obj0 = 0 ;
26437 PyObject * obj1 = 0 ;
26438 char * kwnames[] = {
26439 (char *) "eventType",(char *) "id", NULL
26440 };
26441
26442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26443 if (obj0) {
26444 ecode1 = SWIG_AsVal_int(obj0, &val1);
26445 if (!SWIG_IsOK(ecode1)) {
26446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26447 }
26448 arg1 = static_cast< wxEventType >(val1);
26449 }
26450 if (obj1) {
26451 ecode2 = SWIG_AsVal_int(obj1, &val2);
26452 if (!SWIG_IsOK(ecode2)) {
26453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26454 }
26455 arg2 = static_cast< int >(val2);
26456 }
26457 {
26458 PyThreadState* __tstate = wxPyBeginAllowThreads();
26459 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26460 wxPyEndAllowThreads(__tstate);
26461 if (PyErr_Occurred()) SWIG_fail;
26462 }
26463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26464 return resultobj;
26465 fail:
26466 return NULL;
26467 }
26468
26469
26470 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26471 PyObject *resultobj = 0;
26472 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26473 void *argp1 = 0 ;
26474 int res1 = 0 ;
26475 PyObject *swig_obj[1] ;
26476
26477 if (!args) SWIG_fail;
26478 swig_obj[0] = args;
26479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26480 if (!SWIG_IsOK(res1)) {
26481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26482 }
26483 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 delete arg1;
26487
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 resultobj = SWIG_Py_Void();
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26499 PyObject *resultobj = 0;
26500 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26501 PyObject *arg2 = (PyObject *) 0 ;
26502 void *argp1 = 0 ;
26503 int res1 = 0 ;
26504 PyObject * obj0 = 0 ;
26505 PyObject * obj1 = 0 ;
26506 char * kwnames[] = {
26507 (char *) "self",(char *) "self", NULL
26508 };
26509
26510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26512 if (!SWIG_IsOK(res1)) {
26513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26514 }
26515 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26516 arg2 = obj1;
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 (arg1)->SetSelf(arg2);
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_Py_Void();
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26531 PyObject *resultobj = 0;
26532 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26533 PyObject *result = 0 ;
26534 void *argp1 = 0 ;
26535 int res1 = 0 ;
26536 PyObject *swig_obj[1] ;
26537
26538 if (!args) SWIG_fail;
26539 swig_obj[0] = args;
26540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26541 if (!SWIG_IsOK(res1)) {
26542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26543 }
26544 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 result = (PyObject *)(arg1)->GetSelf();
26548 wxPyEndAllowThreads(__tstate);
26549 if (PyErr_Occurred()) SWIG_fail;
26550 }
26551 resultobj = result;
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26559 PyObject *obj;
26560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26562 return SWIG_Py_Void();
26563 }
26564
26565 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 return SWIG_Python_InitShadowInstance(args);
26567 }
26568
26569 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26570 PyObject *resultobj = 0;
26571 wxWindow *arg1 = (wxWindow *) 0 ;
26572 wxDateTime *arg2 = 0 ;
26573 wxEventType arg3 ;
26574 wxDateEvent *result = 0 ;
26575 void *argp1 = 0 ;
26576 int res1 = 0 ;
26577 void *argp2 = 0 ;
26578 int res2 = 0 ;
26579 int val3 ;
26580 int ecode3 = 0 ;
26581 PyObject * obj0 = 0 ;
26582 PyObject * obj1 = 0 ;
26583 PyObject * obj2 = 0 ;
26584 char * kwnames[] = {
26585 (char *) "win",(char *) "dt",(char *) "type", NULL
26586 };
26587
26588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26592 }
26593 arg1 = reinterpret_cast< wxWindow * >(argp1);
26594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26595 if (!SWIG_IsOK(res2)) {
26596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26597 }
26598 if (!argp2) {
26599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26600 }
26601 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26602 ecode3 = SWIG_AsVal_int(obj2, &val3);
26603 if (!SWIG_IsOK(ecode3)) {
26604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26605 }
26606 arg3 = static_cast< wxEventType >(val3);
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26621 PyObject *resultobj = 0;
26622 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26623 wxDateTime *result = 0 ;
26624 void *argp1 = 0 ;
26625 int res1 = 0 ;
26626 PyObject *swig_obj[1] ;
26627
26628 if (!args) SWIG_fail;
26629 swig_obj[0] = args;
26630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26631 if (!SWIG_IsOK(res1)) {
26632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26633 }
26634 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 {
26638 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26639 result = (wxDateTime *) &_result_ref;
26640 }
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj = 0;
26653 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26654 wxDateTime *arg2 = 0 ;
26655 void *argp1 = 0 ;
26656 int res1 = 0 ;
26657 void *argp2 = 0 ;
26658 int res2 = 0 ;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661 char * kwnames[] = {
26662 (char *) "self",(char *) "date", NULL
26663 };
26664
26665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26667 if (!SWIG_IsOK(res1)) {
26668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26669 }
26670 arg1 = reinterpret_cast< wxDateEvent * >(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 '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26674 }
26675 if (!argp2) {
26676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26677 }
26678 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 (arg1)->SetDate((wxDateTime const &)*arg2);
26682 wxPyEndAllowThreads(__tstate);
26683 if (PyErr_Occurred()) SWIG_fail;
26684 }
26685 resultobj = SWIG_Py_Void();
26686 return resultobj;
26687 fail:
26688 return NULL;
26689 }
26690
26691
26692 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26693 PyObject *obj;
26694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26695 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26696 return SWIG_Py_Void();
26697 }
26698
26699 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26700 return SWIG_Python_InitShadowInstance(args);
26701 }
26702
26703 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26704 PyObject *resultobj = 0;
26705 wxPyApp *result = 0 ;
26706
26707 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (wxPyApp *)new_wxPyApp();
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 PyObject *resultobj = 0;
26723 wxPyApp *arg1 = (wxPyApp *) 0 ;
26724 void *argp1 = 0 ;
26725 int res1 = 0 ;
26726 PyObject *swig_obj[1] ;
26727
26728 if (!args) SWIG_fail;
26729 swig_obj[0] = args;
26730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26731 if (!SWIG_IsOK(res1)) {
26732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26733 }
26734 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26735 {
26736 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 delete arg1;
26738
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 resultobj = SWIG_Py_Void();
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 wxPyApp *arg1 = (wxPyApp *) 0 ;
26752 PyObject *arg2 = (PyObject *) 0 ;
26753 PyObject *arg3 = (PyObject *) 0 ;
26754 bool arg4 ;
26755 void *argp1 = 0 ;
26756 int res1 = 0 ;
26757 bool val4 ;
26758 int ecode4 = 0 ;
26759 PyObject * obj0 = 0 ;
26760 PyObject * obj1 = 0 ;
26761 PyObject * obj2 = 0 ;
26762 PyObject * obj3 = 0 ;
26763 char * kwnames[] = {
26764 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26765 };
26766
26767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26771 }
26772 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26773 arg2 = obj1;
26774 arg3 = obj2;
26775 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26776 if (!SWIG_IsOK(ecode4)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26778 }
26779 arg4 = static_cast< bool >(val4);
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_Py_Void();
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 PyObject *resultobj = 0;
26795 wxPyApp *arg1 = (wxPyApp *) 0 ;
26796 wxString result;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 PyObject *swig_obj[1] ;
26800
26801 if (!args) SWIG_fail;
26802 swig_obj[0] = args;
26803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26806 }
26807 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = ((wxPyApp const *)arg1)->GetAppName();
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 {
26815 #if wxUSE_UNICODE
26816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26817 #else
26818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26819 #endif
26820 }
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj = 0;
26829 wxPyApp *arg1 = (wxPyApp *) 0 ;
26830 wxString *arg2 = 0 ;
26831 void *argp1 = 0 ;
26832 int res1 = 0 ;
26833 bool temp2 = false ;
26834 PyObject * obj0 = 0 ;
26835 PyObject * obj1 = 0 ;
26836 char * kwnames[] = {
26837 (char *) "self",(char *) "name", NULL
26838 };
26839
26840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26842 if (!SWIG_IsOK(res1)) {
26843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26844 }
26845 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26846 {
26847 arg2 = wxString_in_helper(obj1);
26848 if (arg2 == NULL) SWIG_fail;
26849 temp2 = true;
26850 }
26851 {
26852 PyThreadState* __tstate = wxPyBeginAllowThreads();
26853 (arg1)->SetAppName((wxString const &)*arg2);
26854 wxPyEndAllowThreads(__tstate);
26855 if (PyErr_Occurred()) SWIG_fail;
26856 }
26857 resultobj = SWIG_Py_Void();
26858 {
26859 if (temp2)
26860 delete arg2;
26861 }
26862 return resultobj;
26863 fail:
26864 {
26865 if (temp2)
26866 delete arg2;
26867 }
26868 return NULL;
26869 }
26870
26871
26872 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26873 PyObject *resultobj = 0;
26874 wxPyApp *arg1 = (wxPyApp *) 0 ;
26875 wxString result;
26876 void *argp1 = 0 ;
26877 int res1 = 0 ;
26878 PyObject *swig_obj[1] ;
26879
26880 if (!args) SWIG_fail;
26881 swig_obj[0] = args;
26882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26883 if (!SWIG_IsOK(res1)) {
26884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26885 }
26886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 result = ((wxPyApp const *)arg1)->GetClassName();
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 {
26894 #if wxUSE_UNICODE
26895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26896 #else
26897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26898 #endif
26899 }
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26907 PyObject *resultobj = 0;
26908 wxPyApp *arg1 = (wxPyApp *) 0 ;
26909 wxString *arg2 = 0 ;
26910 void *argp1 = 0 ;
26911 int res1 = 0 ;
26912 bool temp2 = false ;
26913 PyObject * obj0 = 0 ;
26914 PyObject * obj1 = 0 ;
26915 char * kwnames[] = {
26916 (char *) "self",(char *) "name", NULL
26917 };
26918
26919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26921 if (!SWIG_IsOK(res1)) {
26922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26923 }
26924 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26925 {
26926 arg2 = wxString_in_helper(obj1);
26927 if (arg2 == NULL) SWIG_fail;
26928 temp2 = true;
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->SetClassName((wxString const &)*arg2);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_Py_Void();
26937 {
26938 if (temp2)
26939 delete arg2;
26940 }
26941 return resultobj;
26942 fail:
26943 {
26944 if (temp2)
26945 delete arg2;
26946 }
26947 return NULL;
26948 }
26949
26950
26951 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26952 PyObject *resultobj = 0;
26953 wxPyApp *arg1 = (wxPyApp *) 0 ;
26954 wxString *result = 0 ;
26955 void *argp1 = 0 ;
26956 int res1 = 0 ;
26957 PyObject *swig_obj[1] ;
26958
26959 if (!args) SWIG_fail;
26960 swig_obj[0] = args;
26961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26962 if (!SWIG_IsOK(res1)) {
26963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26964 }
26965 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 {
26969 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26970 result = (wxString *) &_result_ref;
26971 }
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 {
26976 #if wxUSE_UNICODE
26977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26978 #else
26979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26980 #endif
26981 }
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26989 PyObject *resultobj = 0;
26990 wxPyApp *arg1 = (wxPyApp *) 0 ;
26991 wxString *arg2 = 0 ;
26992 void *argp1 = 0 ;
26993 int res1 = 0 ;
26994 bool temp2 = false ;
26995 PyObject * obj0 = 0 ;
26996 PyObject * obj1 = 0 ;
26997 char * kwnames[] = {
26998 (char *) "self",(char *) "name", NULL
26999 };
27000
27001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27003 if (!SWIG_IsOK(res1)) {
27004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27005 }
27006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27007 {
27008 arg2 = wxString_in_helper(obj1);
27009 if (arg2 == NULL) SWIG_fail;
27010 temp2 = true;
27011 }
27012 {
27013 PyThreadState* __tstate = wxPyBeginAllowThreads();
27014 (arg1)->SetVendorName((wxString const &)*arg2);
27015 wxPyEndAllowThreads(__tstate);
27016 if (PyErr_Occurred()) SWIG_fail;
27017 }
27018 resultobj = SWIG_Py_Void();
27019 {
27020 if (temp2)
27021 delete arg2;
27022 }
27023 return resultobj;
27024 fail:
27025 {
27026 if (temp2)
27027 delete arg2;
27028 }
27029 return NULL;
27030 }
27031
27032
27033 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27034 PyObject *resultobj = 0;
27035 wxPyApp *arg1 = (wxPyApp *) 0 ;
27036 wxAppTraits *result = 0 ;
27037 void *argp1 = 0 ;
27038 int res1 = 0 ;
27039 PyObject *swig_obj[1] ;
27040
27041 if (!args) SWIG_fail;
27042 swig_obj[0] = args;
27043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27044 if (!SWIG_IsOK(res1)) {
27045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27046 }
27047 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = (wxAppTraits *)(arg1)->GetTraits();
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27055 return resultobj;
27056 fail:
27057 return NULL;
27058 }
27059
27060
27061 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27062 PyObject *resultobj = 0;
27063 wxPyApp *arg1 = (wxPyApp *) 0 ;
27064 void *argp1 = 0 ;
27065 int res1 = 0 ;
27066 PyObject *swig_obj[1] ;
27067
27068 if (!args) SWIG_fail;
27069 swig_obj[0] = args;
27070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27071 if (!SWIG_IsOK(res1)) {
27072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27073 }
27074 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 (arg1)->ProcessPendingEvents();
27078 wxPyEndAllowThreads(__tstate);
27079 if (PyErr_Occurred()) SWIG_fail;
27080 }
27081 resultobj = SWIG_Py_Void();
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj = 0;
27090 wxPyApp *arg1 = (wxPyApp *) 0 ;
27091 bool arg2 = (bool) false ;
27092 bool result;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 bool val2 ;
27096 int ecode2 = 0 ;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "onlyIfNeeded", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27107 }
27108 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27109 if (obj1) {
27110 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27111 if (!SWIG_IsOK(ecode2)) {
27112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27113 }
27114 arg2 = static_cast< bool >(val2);
27115 }
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 result = (bool)(arg1)->Yield(arg2);
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 {
27123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27124 }
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27132 PyObject *resultobj = 0;
27133 wxPyApp *arg1 = (wxPyApp *) 0 ;
27134 void *argp1 = 0 ;
27135 int res1 = 0 ;
27136 PyObject *swig_obj[1] ;
27137
27138 if (!args) SWIG_fail;
27139 swig_obj[0] = args;
27140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27141 if (!SWIG_IsOK(res1)) {
27142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27143 }
27144 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 (arg1)->WakeUpIdle();
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 resultobj = SWIG_Py_Void();
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27159 PyObject *resultobj = 0;
27160 bool result;
27161
27162 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27163 {
27164 PyThreadState* __tstate = wxPyBeginAllowThreads();
27165 result = (bool)wxPyApp::IsMainLoopRunning();
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27179 PyObject *resultobj = 0;
27180 wxPyApp *arg1 = (wxPyApp *) 0 ;
27181 int result;
27182 void *argp1 = 0 ;
27183 int res1 = 0 ;
27184 PyObject *swig_obj[1] ;
27185
27186 if (!args) SWIG_fail;
27187 swig_obj[0] = args;
27188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27189 if (!SWIG_IsOK(res1)) {
27190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27191 }
27192 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (int)(arg1)->MainLoop();
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 resultobj = SWIG_From_int(static_cast< int >(result));
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27207 PyObject *resultobj = 0;
27208 wxPyApp *arg1 = (wxPyApp *) 0 ;
27209 void *argp1 = 0 ;
27210 int res1 = 0 ;
27211 PyObject *swig_obj[1] ;
27212
27213 if (!args) SWIG_fail;
27214 swig_obj[0] = args;
27215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27216 if (!SWIG_IsOK(res1)) {
27217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27218 }
27219 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 (arg1)->Exit();
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 resultobj = SWIG_Py_Void();
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27234 PyObject *resultobj = 0;
27235 wxPyApp *arg1 = (wxPyApp *) 0 ;
27236 void *argp1 = 0 ;
27237 int res1 = 0 ;
27238 PyObject *swig_obj[1] ;
27239
27240 if (!args) SWIG_fail;
27241 swig_obj[0] = args;
27242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27245 }
27246 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 (arg1)->ExitMainLoop();
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 resultobj = SWIG_Py_Void();
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27261 PyObject *resultobj = 0;
27262 wxPyApp *arg1 = (wxPyApp *) 0 ;
27263 bool result;
27264 void *argp1 = 0 ;
27265 int res1 = 0 ;
27266 PyObject *swig_obj[1] ;
27267
27268 if (!args) SWIG_fail;
27269 swig_obj[0] = args;
27270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27271 if (!SWIG_IsOK(res1)) {
27272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27273 }
27274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27275 {
27276 PyThreadState* __tstate = wxPyBeginAllowThreads();
27277 result = (bool)(arg1)->Pending();
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 {
27282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27283 }
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27291 PyObject *resultobj = 0;
27292 wxPyApp *arg1 = (wxPyApp *) 0 ;
27293 bool result;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 PyObject *swig_obj[1] ;
27297
27298 if (!args) SWIG_fail;
27299 swig_obj[0] = args;
27300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27301 if (!SWIG_IsOK(res1)) {
27302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27303 }
27304 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)(arg1)->Dispatch();
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 {
27312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27313 }
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27321 PyObject *resultobj = 0;
27322 wxPyApp *arg1 = (wxPyApp *) 0 ;
27323 bool result;
27324 void *argp1 = 0 ;
27325 int res1 = 0 ;
27326 PyObject *swig_obj[1] ;
27327
27328 if (!args) SWIG_fail;
27329 swig_obj[0] = args;
27330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27331 if (!SWIG_IsOK(res1)) {
27332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27333 }
27334 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 result = (bool)(arg1)->ProcessIdle();
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 {
27342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27343 }
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj = 0;
27352 wxPyApp *arg1 = (wxPyApp *) 0 ;
27353 wxWindow *arg2 = (wxWindow *) 0 ;
27354 wxIdleEvent *arg3 = 0 ;
27355 bool result;
27356 void *argp1 = 0 ;
27357 int res1 = 0 ;
27358 void *argp2 = 0 ;
27359 int res2 = 0 ;
27360 void *argp3 = 0 ;
27361 int res3 = 0 ;
27362 PyObject * obj0 = 0 ;
27363 PyObject * obj1 = 0 ;
27364 PyObject * obj2 = 0 ;
27365 char * kwnames[] = {
27366 (char *) "self",(char *) "win",(char *) "event", NULL
27367 };
27368
27369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27371 if (!SWIG_IsOK(res1)) {
27372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27373 }
27374 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27376 if (!SWIG_IsOK(res2)) {
27377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27378 }
27379 arg2 = reinterpret_cast< wxWindow * >(argp2);
27380 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27381 if (!SWIG_IsOK(res3)) {
27382 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27383 }
27384 if (!argp3) {
27385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27386 }
27387 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 {
27395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27396 }
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27404 PyObject *resultobj = 0;
27405 wxPyApp *arg1 = (wxPyApp *) 0 ;
27406 bool result;
27407 void *argp1 = 0 ;
27408 int res1 = 0 ;
27409 PyObject *swig_obj[1] ;
27410
27411 if (!args) SWIG_fail;
27412 swig_obj[0] = args;
27413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27414 if (!SWIG_IsOK(res1)) {
27415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27416 }
27417 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 result = (bool)((wxPyApp const *)arg1)->IsActive();
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 {
27425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27426 }
27427 return resultobj;
27428 fail:
27429 return NULL;
27430 }
27431
27432
27433 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27434 PyObject *resultobj = 0;
27435 wxPyApp *arg1 = (wxPyApp *) 0 ;
27436 wxWindow *arg2 = (wxWindow *) 0 ;
27437 void *argp1 = 0 ;
27438 int res1 = 0 ;
27439 void *argp2 = 0 ;
27440 int res2 = 0 ;
27441 PyObject * obj0 = 0 ;
27442 PyObject * obj1 = 0 ;
27443 char * kwnames[] = {
27444 (char *) "self",(char *) "win", NULL
27445 };
27446
27447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27451 }
27452 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27454 if (!SWIG_IsOK(res2)) {
27455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27456 }
27457 arg2 = reinterpret_cast< wxWindow * >(argp2);
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 (arg1)->SetTopWindow(arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_Py_Void();
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxPyApp *arg1 = (wxPyApp *) 0 ;
27474 wxWindow *result = 0 ;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 PyObject *swig_obj[1] ;
27478
27479 if (!args) SWIG_fail;
27480 swig_obj[0] = args;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27484 }
27485 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = wxPyMake_wxObject(result, (bool)0);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj = 0;
27503 wxPyApp *arg1 = (wxPyApp *) 0 ;
27504 bool arg2 ;
27505 void *argp1 = 0 ;
27506 int res1 = 0 ;
27507 bool val2 ;
27508 int ecode2 = 0 ;
27509 PyObject * obj0 = 0 ;
27510 PyObject * obj1 = 0 ;
27511 char * kwnames[] = {
27512 (char *) "self",(char *) "flag", NULL
27513 };
27514
27515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27517 if (!SWIG_IsOK(res1)) {
27518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27519 }
27520 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27521 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27522 if (!SWIG_IsOK(ecode2)) {
27523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27524 }
27525 arg2 = static_cast< bool >(val2);
27526 {
27527 PyThreadState* __tstate = wxPyBeginAllowThreads();
27528 (arg1)->SetExitOnFrameDelete(arg2);
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 resultobj = SWIG_Py_Void();
27533 return resultobj;
27534 fail:
27535 return NULL;
27536 }
27537
27538
27539 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27540 PyObject *resultobj = 0;
27541 wxPyApp *arg1 = (wxPyApp *) 0 ;
27542 bool result;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 PyObject *swig_obj[1] ;
27546
27547 if (!args) SWIG_fail;
27548 swig_obj[0] = args;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27552 }
27553 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 {
27561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27562 }
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27570 PyObject *resultobj = 0;
27571 wxPyApp *arg1 = (wxPyApp *) 0 ;
27572 bool arg2 ;
27573 void *argp1 = 0 ;
27574 int res1 = 0 ;
27575 bool val2 ;
27576 int ecode2 = 0 ;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 char * kwnames[] = {
27580 (char *) "self",(char *) "flag", NULL
27581 };
27582
27583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27585 if (!SWIG_IsOK(res1)) {
27586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27587 }
27588 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27590 if (!SWIG_IsOK(ecode2)) {
27591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27592 }
27593 arg2 = static_cast< bool >(val2);
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 (arg1)->SetUseBestVisual(arg2);
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 resultobj = SWIG_Py_Void();
27601 return resultobj;
27602 fail:
27603 return NULL;
27604 }
27605
27606
27607 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 PyObject *resultobj = 0;
27609 wxPyApp *arg1 = (wxPyApp *) 0 ;
27610 bool result;
27611 void *argp1 = 0 ;
27612 int res1 = 0 ;
27613 PyObject *swig_obj[1] ;
27614
27615 if (!args) SWIG_fail;
27616 swig_obj[0] = args;
27617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27618 if (!SWIG_IsOK(res1)) {
27619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27620 }
27621 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27625 wxPyEndAllowThreads(__tstate);
27626 if (PyErr_Occurred()) SWIG_fail;
27627 }
27628 {
27629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27630 }
27631 return resultobj;
27632 fail:
27633 return NULL;
27634 }
27635
27636
27637 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27638 PyObject *resultobj = 0;
27639 wxPyApp *arg1 = (wxPyApp *) 0 ;
27640 int arg2 ;
27641 void *argp1 = 0 ;
27642 int res1 = 0 ;
27643 int val2 ;
27644 int ecode2 = 0 ;
27645 PyObject * obj0 = 0 ;
27646 PyObject * obj1 = 0 ;
27647 char * kwnames[] = {
27648 (char *) "self",(char *) "mode", NULL
27649 };
27650
27651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27653 if (!SWIG_IsOK(res1)) {
27654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27655 }
27656 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27657 ecode2 = SWIG_AsVal_int(obj1, &val2);
27658 if (!SWIG_IsOK(ecode2)) {
27659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27660 }
27661 arg2 = static_cast< int >(val2);
27662 {
27663 PyThreadState* __tstate = wxPyBeginAllowThreads();
27664 (arg1)->SetPrintMode(arg2);
27665 wxPyEndAllowThreads(__tstate);
27666 if (PyErr_Occurred()) SWIG_fail;
27667 }
27668 resultobj = SWIG_Py_Void();
27669 return resultobj;
27670 fail:
27671 return NULL;
27672 }
27673
27674
27675 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27676 PyObject *resultobj = 0;
27677 wxPyApp *arg1 = (wxPyApp *) 0 ;
27678 int result;
27679 void *argp1 = 0 ;
27680 int res1 = 0 ;
27681 PyObject *swig_obj[1] ;
27682
27683 if (!args) SWIG_fail;
27684 swig_obj[0] = args;
27685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27686 if (!SWIG_IsOK(res1)) {
27687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27688 }
27689 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_From_int(static_cast< int >(result));
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj = 0;
27705 wxPyApp *arg1 = (wxPyApp *) 0 ;
27706 int arg2 ;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 int val2 ;
27710 int ecode2 = 0 ;
27711 PyObject * obj0 = 0 ;
27712 PyObject * obj1 = 0 ;
27713 char * kwnames[] = {
27714 (char *) "self",(char *) "mode", NULL
27715 };
27716
27717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27721 }
27722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27723 ecode2 = SWIG_AsVal_int(obj1, &val2);
27724 if (!SWIG_IsOK(ecode2)) {
27725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27726 }
27727 arg2 = static_cast< int >(val2);
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->SetAssertMode(arg2);
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 resultobj = SWIG_Py_Void();
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27742 PyObject *resultobj = 0;
27743 wxPyApp *arg1 = (wxPyApp *) 0 ;
27744 int result;
27745 void *argp1 = 0 ;
27746 int res1 = 0 ;
27747 PyObject *swig_obj[1] ;
27748
27749 if (!args) SWIG_fail;
27750 swig_obj[0] = args;
27751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27752 if (!SWIG_IsOK(res1)) {
27753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27754 }
27755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = (int)(arg1)->GetAssertMode();
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_From_int(static_cast< int >(result));
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27770 PyObject *resultobj = 0;
27771 bool result;
27772
27773 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27777 wxPyEndAllowThreads(__tstate);
27778 if (PyErr_Occurred()) SWIG_fail;
27779 }
27780 {
27781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27782 }
27783 return resultobj;
27784 fail:
27785 return NULL;
27786 }
27787
27788
27789 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27790 PyObject *resultobj = 0;
27791 long result;
27792
27793 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 result = (long)wxPyApp::GetMacAboutMenuItemId();
27797 wxPyEndAllowThreads(__tstate);
27798 if (PyErr_Occurred()) SWIG_fail;
27799 }
27800 resultobj = SWIG_From_long(static_cast< long >(result));
27801 return resultobj;
27802 fail:
27803 return NULL;
27804 }
27805
27806
27807 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27808 PyObject *resultobj = 0;
27809 long result;
27810
27811 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 resultobj = SWIG_From_long(static_cast< long >(result));
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 long result;
27828
27829 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 result = (long)wxPyApp::GetMacExitMenuItemId();
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 resultobj = SWIG_From_long(static_cast< long >(result));
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27844 PyObject *resultobj = 0;
27845 wxString result;
27846
27847 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = wxPyApp::GetMacHelpMenuTitleName();
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 {
27855 #if wxUSE_UNICODE
27856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27857 #else
27858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27859 #endif
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 bool arg1 ;
27870 bool val1 ;
27871 int ecode1 = 0 ;
27872 PyObject * obj0 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "val", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27878 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27879 if (!SWIG_IsOK(ecode1)) {
27880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27881 }
27882 arg1 = static_cast< bool >(val1);
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 resultobj = SWIG_Py_Void();
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj = 0;
27898 long arg1 ;
27899 long val1 ;
27900 int ecode1 = 0 ;
27901 PyObject * obj0 = 0 ;
27902 char * kwnames[] = {
27903 (char *) "val", NULL
27904 };
27905
27906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27907 ecode1 = SWIG_AsVal_long(obj0, &val1);
27908 if (!SWIG_IsOK(ecode1)) {
27909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27910 }
27911 arg1 = static_cast< long >(val1);
27912 {
27913 PyThreadState* __tstate = wxPyBeginAllowThreads();
27914 wxPyApp::SetMacAboutMenuItemId(arg1);
27915 wxPyEndAllowThreads(__tstate);
27916 if (PyErr_Occurred()) SWIG_fail;
27917 }
27918 resultobj = SWIG_Py_Void();
27919 return resultobj;
27920 fail:
27921 return NULL;
27922 }
27923
27924
27925 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27926 PyObject *resultobj = 0;
27927 long arg1 ;
27928 long val1 ;
27929 int ecode1 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "val", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27936 ecode1 = SWIG_AsVal_long(obj0, &val1);
27937 if (!SWIG_IsOK(ecode1)) {
27938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27939 }
27940 arg1 = static_cast< long >(val1);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_Py_Void();
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj = 0;
27956 long arg1 ;
27957 long val1 ;
27958 int ecode1 = 0 ;
27959 PyObject * obj0 = 0 ;
27960 char * kwnames[] = {
27961 (char *) "val", NULL
27962 };
27963
27964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27965 ecode1 = SWIG_AsVal_long(obj0, &val1);
27966 if (!SWIG_IsOK(ecode1)) {
27967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27968 }
27969 arg1 = static_cast< long >(val1);
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 wxPyApp::SetMacExitMenuItemId(arg1);
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 resultobj = SWIG_Py_Void();
27977 return resultobj;
27978 fail:
27979 return NULL;
27980 }
27981
27982
27983 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27984 PyObject *resultobj = 0;
27985 wxString *arg1 = 0 ;
27986 bool temp1 = false ;
27987 PyObject * obj0 = 0 ;
27988 char * kwnames[] = {
27989 (char *) "val", NULL
27990 };
27991
27992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
27993 {
27994 arg1 = wxString_in_helper(obj0);
27995 if (arg1 == NULL) SWIG_fail;
27996 temp1 = true;
27997 }
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 resultobj = SWIG_Py_Void();
28005 {
28006 if (temp1)
28007 delete arg1;
28008 }
28009 return resultobj;
28010 fail:
28011 {
28012 if (temp1)
28013 delete arg1;
28014 }
28015 return NULL;
28016 }
28017
28018
28019 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28020 PyObject *resultobj = 0;
28021 wxPyApp *arg1 = (wxPyApp *) 0 ;
28022 void *argp1 = 0 ;
28023 int res1 = 0 ;
28024 PyObject *swig_obj[1] ;
28025
28026 if (!args) SWIG_fail;
28027 swig_obj[0] = args;
28028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28029 if (!SWIG_IsOK(res1)) {
28030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28031 }
28032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 (arg1)->_BootstrapApp();
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28047 PyObject *resultobj = 0;
28048 int result;
28049
28050 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 result = (int)wxPyApp_GetComCtl32Version();
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = SWIG_From_int(static_cast< int >(result));
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28065 PyObject *obj;
28066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28067 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28068 return SWIG_Py_Void();
28069 }
28070
28071 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28072 return SWIG_Python_InitShadowInstance(args);
28073 }
28074
28075 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28076 PyObject *resultobj = 0;
28077
28078 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 wxExit();
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 resultobj = SWIG_Py_Void();
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28093 PyObject *resultobj = 0;
28094 bool result;
28095
28096 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 result = (bool)wxYield();
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 {
28104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28105 }
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28113 PyObject *resultobj = 0;
28114 bool result;
28115
28116 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (bool)wxYieldIfNeeded();
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 {
28124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28125 }
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 wxWindow *arg1 = (wxWindow *) NULL ;
28135 bool arg2 = (bool) false ;
28136 bool result;
28137 void *argp1 = 0 ;
28138 int res1 = 0 ;
28139 bool val2 ;
28140 int ecode2 = 0 ;
28141 PyObject * obj0 = 0 ;
28142 PyObject * obj1 = 0 ;
28143 char * kwnames[] = {
28144 (char *) "win",(char *) "onlyIfNeeded", NULL
28145 };
28146
28147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28148 if (obj0) {
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28152 }
28153 arg1 = reinterpret_cast< wxWindow * >(argp1);
28154 }
28155 if (obj1) {
28156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28157 if (!SWIG_IsOK(ecode2)) {
28158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28159 }
28160 arg2 = static_cast< bool >(val2);
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (bool)wxSafeYield(arg1,arg2);
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 {
28169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28170 }
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28178 PyObject *resultobj = 0;
28179
28180 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 wxWakeUpIdle();
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_Py_Void();
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28197 wxEvent *arg2 = 0 ;
28198 void *argp1 = 0 ;
28199 int res1 = 0 ;
28200 void *argp2 = 0 ;
28201 int res2 = 0 ;
28202 PyObject * obj0 = 0 ;
28203 PyObject * obj1 = 0 ;
28204 char * kwnames[] = {
28205 (char *) "dest",(char *) "event", NULL
28206 };
28207
28208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28210 if (!SWIG_IsOK(res1)) {
28211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28212 }
28213 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28215 if (!SWIG_IsOK(res2)) {
28216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28217 }
28218 if (!argp2) {
28219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28220 }
28221 arg2 = reinterpret_cast< wxEvent * >(argp2);
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 wxPostEvent(arg1,*arg2);
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 resultobj = SWIG_Py_Void();
28229 return resultobj;
28230 fail:
28231 return NULL;
28232 }
28233
28234
28235 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28236 PyObject *resultobj = 0;
28237
28238 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 wxApp_CleanUp();
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_Py_Void();
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28253 PyObject *resultobj = 0;
28254 wxPyApp *result = 0 ;
28255
28256 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (wxPyApp *)wxPyGetApp();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = wxPyMake_wxObject(result, 0);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj = 0;
28274 char *arg1 = (char *) 0 ;
28275 int res1 ;
28276 char *buf1 = 0 ;
28277 int alloc1 = 0 ;
28278 PyObject * obj0 = 0 ;
28279 char * kwnames[] = {
28280 (char *) "encoding", NULL
28281 };
28282
28283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28284 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28285 if (!SWIG_IsOK(res1)) {
28286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28287 }
28288 arg1 = buf1;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 wxSetDefaultPyEncoding((char const *)arg1);
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 resultobj = SWIG_Py_Void();
28296 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28297 return resultobj;
28298 fail:
28299 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 char *result = 0 ;
28307
28308 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (char *)wxGetDefaultPyEncoding();
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 resultobj = SWIG_FromCharPtr(result);
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 PyObject *resultobj = 0;
28324 wxEventLoop *result = 0 ;
28325
28326 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (wxEventLoop *)new wxEventLoop();
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28341 PyObject *resultobj = 0;
28342 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28343 void *argp1 = 0 ;
28344 int res1 = 0 ;
28345 PyObject *swig_obj[1] ;
28346
28347 if (!args) SWIG_fail;
28348 swig_obj[0] = args;
28349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28350 if (!SWIG_IsOK(res1)) {
28351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28352 }
28353 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28354 {
28355 PyThreadState* __tstate = wxPyBeginAllowThreads();
28356 delete arg1;
28357
28358 wxPyEndAllowThreads(__tstate);
28359 if (PyErr_Occurred()) SWIG_fail;
28360 }
28361 resultobj = SWIG_Py_Void();
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28369 PyObject *resultobj = 0;
28370 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28371 int result;
28372 void *argp1 = 0 ;
28373 int res1 = 0 ;
28374 PyObject *swig_obj[1] ;
28375
28376 if (!args) SWIG_fail;
28377 swig_obj[0] = args;
28378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28379 if (!SWIG_IsOK(res1)) {
28380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28381 }
28382 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28383 {
28384 PyThreadState* __tstate = wxPyBeginAllowThreads();
28385 result = (int)(arg1)->Run();
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 resultobj = SWIG_From_int(static_cast< int >(result));
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj = 0;
28398 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28399 int arg2 = (int) 0 ;
28400 void *argp1 = 0 ;
28401 int res1 = 0 ;
28402 int val2 ;
28403 int ecode2 = 0 ;
28404 PyObject * obj0 = 0 ;
28405 PyObject * obj1 = 0 ;
28406 char * kwnames[] = {
28407 (char *) "self",(char *) "rc", NULL
28408 };
28409
28410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28412 if (!SWIG_IsOK(res1)) {
28413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28414 }
28415 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28416 if (obj1) {
28417 ecode2 = SWIG_AsVal_int(obj1, &val2);
28418 if (!SWIG_IsOK(ecode2)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28420 }
28421 arg2 = static_cast< int >(val2);
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 (arg1)->Exit(arg2);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_Py_Void();
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28437 PyObject *resultobj = 0;
28438 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28439 bool result;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 PyObject *swig_obj[1] ;
28443
28444 if (!args) SWIG_fail;
28445 swig_obj[0] = args;
28446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28447 if (!SWIG_IsOK(res1)) {
28448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28449 }
28450 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (bool)((wxEventLoop const *)arg1)->Pending();
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 {
28458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28459 }
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28467 PyObject *resultobj = 0;
28468 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28469 bool result;
28470 void *argp1 = 0 ;
28471 int res1 = 0 ;
28472 PyObject *swig_obj[1] ;
28473
28474 if (!args) SWIG_fail;
28475 swig_obj[0] = args;
28476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28479 }
28480 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 result = (bool)(arg1)->Dispatch();
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 {
28488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28489 }
28490 return resultobj;
28491 fail:
28492 return NULL;
28493 }
28494
28495
28496 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28497 PyObject *resultobj = 0;
28498 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28499 bool result;
28500 void *argp1 = 0 ;
28501 int res1 = 0 ;
28502 PyObject *swig_obj[1] ;
28503
28504 if (!args) SWIG_fail;
28505 swig_obj[0] = args;
28506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28507 if (!SWIG_IsOK(res1)) {
28508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28509 }
28510 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 {
28518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28519 }
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28527 PyObject *resultobj = 0;
28528 wxEventLoop *result = 0 ;
28529
28530 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (wxEventLoop *)wxEventLoop::GetActive();
28534 wxPyEndAllowThreads(__tstate);
28535 if (PyErr_Occurred()) SWIG_fail;
28536 }
28537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj = 0;
28546 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28547 void *argp1 = 0 ;
28548 int res1 = 0 ;
28549 PyObject * obj0 = 0 ;
28550 char * kwnames[] = {
28551 (char *) "loop", NULL
28552 };
28553
28554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28556 if (!SWIG_IsOK(res1)) {
28557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28558 }
28559 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 wxEventLoop::SetActive(arg1);
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_Py_Void();
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *obj;
28575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28576 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28577 return SWIG_Py_Void();
28578 }
28579
28580 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28581 return SWIG_Python_InitShadowInstance(args);
28582 }
28583
28584 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28585 PyObject *resultobj = 0;
28586 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28587 wxEventLoopActivator *result = 0 ;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 PyObject * obj0 = 0 ;
28591 char * kwnames[] = {
28592 (char *) "evtLoop", NULL
28593 };
28594
28595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28599 }
28600 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28617 void *argp1 = 0 ;
28618 int res1 = 0 ;
28619 PyObject *swig_obj[1] ;
28620
28621 if (!args) SWIG_fail;
28622 swig_obj[0] = args;
28623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28624 if (!SWIG_IsOK(res1)) {
28625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28626 }
28627 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 delete arg1;
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 resultobj = SWIG_Py_Void();
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 PyObject *obj;
28644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28645 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28646 return SWIG_Py_Void();
28647 }
28648
28649 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 return SWIG_Python_InitShadowInstance(args);
28651 }
28652
28653 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28654 PyObject *resultobj = 0;
28655 int arg1 = (int) 0 ;
28656 int arg2 = (int) 0 ;
28657 int arg3 = (int) 0 ;
28658 wxAcceleratorEntry *result = 0 ;
28659 int val1 ;
28660 int ecode1 = 0 ;
28661 int val2 ;
28662 int ecode2 = 0 ;
28663 int val3 ;
28664 int ecode3 = 0 ;
28665 PyObject * obj0 = 0 ;
28666 PyObject * obj1 = 0 ;
28667 PyObject * obj2 = 0 ;
28668 char * kwnames[] = {
28669 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28670 };
28671
28672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28673 if (obj0) {
28674 ecode1 = SWIG_AsVal_int(obj0, &val1);
28675 if (!SWIG_IsOK(ecode1)) {
28676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28677 }
28678 arg1 = static_cast< int >(val1);
28679 }
28680 if (obj1) {
28681 ecode2 = SWIG_AsVal_int(obj1, &val2);
28682 if (!SWIG_IsOK(ecode2)) {
28683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28684 }
28685 arg2 = static_cast< int >(val2);
28686 }
28687 if (obj2) {
28688 ecode3 = SWIG_AsVal_int(obj2, &val3);
28689 if (!SWIG_IsOK(ecode3)) {
28690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28691 }
28692 arg3 = static_cast< int >(val3);
28693 }
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28697 wxPyEndAllowThreads(__tstate);
28698 if (PyErr_Occurred()) SWIG_fail;
28699 }
28700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28708 PyObject *resultobj = 0;
28709 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28710 void *argp1 = 0 ;
28711 int res1 = 0 ;
28712 PyObject *swig_obj[1] ;
28713
28714 if (!args) SWIG_fail;
28715 swig_obj[0] = args;
28716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28717 if (!SWIG_IsOK(res1)) {
28718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28719 }
28720 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28721 {
28722 PyThreadState* __tstate = wxPyBeginAllowThreads();
28723 delete arg1;
28724
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_Py_Void();
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28736 PyObject *resultobj = 0;
28737 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28738 int arg2 ;
28739 int arg3 ;
28740 int arg4 ;
28741 void *argp1 = 0 ;
28742 int res1 = 0 ;
28743 int val2 ;
28744 int ecode2 = 0 ;
28745 int val3 ;
28746 int ecode3 = 0 ;
28747 int val4 ;
28748 int ecode4 = 0 ;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28751 PyObject * obj2 = 0 ;
28752 PyObject * obj3 = 0 ;
28753 char * kwnames[] = {
28754 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28755 };
28756
28757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28759 if (!SWIG_IsOK(res1)) {
28760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28761 }
28762 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28763 ecode2 = SWIG_AsVal_int(obj1, &val2);
28764 if (!SWIG_IsOK(ecode2)) {
28765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28766 }
28767 arg2 = static_cast< int >(val2);
28768 ecode3 = SWIG_AsVal_int(obj2, &val3);
28769 if (!SWIG_IsOK(ecode3)) {
28770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28771 }
28772 arg3 = static_cast< int >(val3);
28773 ecode4 = SWIG_AsVal_int(obj3, &val4);
28774 if (!SWIG_IsOK(ecode4)) {
28775 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28776 }
28777 arg4 = static_cast< int >(val4);
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 (arg1)->Set(arg2,arg3,arg4);
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 resultobj = SWIG_Py_Void();
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28792 PyObject *resultobj = 0;
28793 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28794 int result;
28795 void *argp1 = 0 ;
28796 int res1 = 0 ;
28797 PyObject *swig_obj[1] ;
28798
28799 if (!args) SWIG_fail;
28800 swig_obj[0] = args;
28801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28802 if (!SWIG_IsOK(res1)) {
28803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28804 }
28805 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 result = (int)(arg1)->GetFlags();
28809 wxPyEndAllowThreads(__tstate);
28810 if (PyErr_Occurred()) SWIG_fail;
28811 }
28812 resultobj = SWIG_From_int(static_cast< int >(result));
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28820 PyObject *resultobj = 0;
28821 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28822 int result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 PyObject *swig_obj[1] ;
28826
28827 if (!args) SWIG_fail;
28828 swig_obj[0] = args;
28829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28830 if (!SWIG_IsOK(res1)) {
28831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28832 }
28833 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (int)(arg1)->GetKeyCode();
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 resultobj = SWIG_From_int(static_cast< int >(result));
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28848 PyObject *resultobj = 0;
28849 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28850 int result;
28851 void *argp1 = 0 ;
28852 int res1 = 0 ;
28853 PyObject *swig_obj[1] ;
28854
28855 if (!args) SWIG_fail;
28856 swig_obj[0] = args;
28857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28858 if (!SWIG_IsOK(res1)) {
28859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28860 }
28861 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 result = (int)(arg1)->GetCommand();
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 resultobj = SWIG_From_int(static_cast< int >(result));
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28876 PyObject *obj;
28877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28878 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28879 return SWIG_Py_Void();
28880 }
28881
28882 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28883 return SWIG_Python_InitShadowInstance(args);
28884 }
28885
28886 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj = 0;
28888 int arg1 ;
28889 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28890 wxAcceleratorTable *result = 0 ;
28891 PyObject * obj0 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "n", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28897 {
28898 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28899 if (arg2) arg1 = PyList_Size(obj0);
28900 else arg1 = 0;
28901 }
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28916 PyObject *resultobj = 0;
28917 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28918 void *argp1 = 0 ;
28919 int res1 = 0 ;
28920 PyObject *swig_obj[1] ;
28921
28922 if (!args) SWIG_fail;
28923 swig_obj[0] = args;
28924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28927 }
28928 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 delete arg1;
28932
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_Py_Void();
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28946 bool result;
28947 void *argp1 = 0 ;
28948 int res1 = 0 ;
28949 PyObject *swig_obj[1] ;
28950
28951 if (!args) SWIG_fail;
28952 swig_obj[0] = args;
28953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28954 if (!SWIG_IsOK(res1)) {
28955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28956 }
28957 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 {
28965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28966 }
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28974 PyObject *obj;
28975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28976 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28977 return SWIG_Py_Void();
28978 }
28979
28980 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 return SWIG_Python_InitShadowInstance(args);
28982 }
28983
28984 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28985 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28986 return 1;
28987 }
28988
28989
28990 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
28991 PyObject *pyobj = 0;
28992
28993 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
28994 return pyobj;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28999 PyObject *resultobj = 0;
29000 wxString *arg1 = 0 ;
29001 wxAcceleratorEntry *result = 0 ;
29002 bool temp1 = false ;
29003 PyObject * obj0 = 0 ;
29004 char * kwnames[] = {
29005 (char *) "label", NULL
29006 };
29007
29008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29009 {
29010 arg1 = wxString_in_helper(obj0);
29011 if (arg1 == NULL) SWIG_fail;
29012 temp1 = true;
29013 }
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29021 {
29022 if (temp1)
29023 delete arg1;
29024 }
29025 return resultobj;
29026 fail:
29027 {
29028 if (temp1)
29029 delete arg1;
29030 }
29031 return NULL;
29032 }
29033
29034
29035 SWIGINTERN int PanelNameStr_set(PyObject *) {
29036 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29037 return 1;
29038 }
29039
29040
29041 SWIGINTERN PyObject *PanelNameStr_get(void) {
29042 PyObject *pyobj = 0;
29043
29044 {
29045 #if wxUSE_UNICODE
29046 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29047 #else
29048 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29049 #endif
29050 }
29051 return pyobj;
29052 }
29053
29054
29055 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29056 PyObject *resultobj = 0;
29057 wxVisualAttributes *result = 0 ;
29058
29059 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29060 {
29061 PyThreadState* __tstate = wxPyBeginAllowThreads();
29062 result = (wxVisualAttributes *)new_wxVisualAttributes();
29063 wxPyEndAllowThreads(__tstate);
29064 if (PyErr_Occurred()) SWIG_fail;
29065 }
29066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29067 return resultobj;
29068 fail:
29069 return NULL;
29070 }
29071
29072
29073 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29074 PyObject *resultobj = 0;
29075 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29076 void *argp1 = 0 ;
29077 int res1 = 0 ;
29078 PyObject *swig_obj[1] ;
29079
29080 if (!args) SWIG_fail;
29081 swig_obj[0] = args;
29082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29083 if (!SWIG_IsOK(res1)) {
29084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29085 }
29086 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29087 {
29088 PyThreadState* __tstate = wxPyBeginAllowThreads();
29089 delete_wxVisualAttributes(arg1);
29090
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 resultobj = SWIG_Py_Void();
29095 return resultobj;
29096 fail:
29097 return NULL;
29098 }
29099
29100
29101 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29102 PyObject *resultobj = 0;
29103 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29104 wxFont *arg2 = (wxFont *) 0 ;
29105 void *argp1 = 0 ;
29106 int res1 = 0 ;
29107 void *argp2 = 0 ;
29108 int res2 = 0 ;
29109 PyObject *swig_obj[2] ;
29110
29111 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29113 if (!SWIG_IsOK(res1)) {
29114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29115 }
29116 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29117 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29118 if (!SWIG_IsOK(res2)) {
29119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29120 }
29121 arg2 = reinterpret_cast< wxFont * >(argp2);
29122 if (arg1) (arg1)->font = *arg2;
29123
29124 resultobj = SWIG_Py_Void();
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29132 PyObject *resultobj = 0;
29133 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29134 wxFont *result = 0 ;
29135 void *argp1 = 0 ;
29136 int res1 = 0 ;
29137 PyObject *swig_obj[1] ;
29138
29139 if (!args) SWIG_fail;
29140 swig_obj[0] = args;
29141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29142 if (!SWIG_IsOK(res1)) {
29143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29144 }
29145 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29146 result = (wxFont *)& ((arg1)->font);
29147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29155 PyObject *resultobj = 0;
29156 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29157 wxColour *arg2 = (wxColour *) 0 ;
29158 void *argp1 = 0 ;
29159 int res1 = 0 ;
29160 void *argp2 = 0 ;
29161 int res2 = 0 ;
29162 PyObject *swig_obj[2] ;
29163
29164 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29166 if (!SWIG_IsOK(res1)) {
29167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29168 }
29169 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29170 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29171 if (!SWIG_IsOK(res2)) {
29172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29173 }
29174 arg2 = reinterpret_cast< wxColour * >(argp2);
29175 if (arg1) (arg1)->colFg = *arg2;
29176
29177 resultobj = SWIG_Py_Void();
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29187 wxColour *result = 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 PyObject *swig_obj[1] ;
29191
29192 if (!args) SWIG_fail;
29193 swig_obj[0] = args;
29194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29195 if (!SWIG_IsOK(res1)) {
29196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29197 }
29198 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29199 result = (wxColour *)& ((arg1)->colFg);
29200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29208 PyObject *resultobj = 0;
29209 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29210 wxColour *arg2 = (wxColour *) 0 ;
29211 void *argp1 = 0 ;
29212 int res1 = 0 ;
29213 void *argp2 = 0 ;
29214 int res2 = 0 ;
29215 PyObject *swig_obj[2] ;
29216
29217 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
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_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29221 }
29222 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29223 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29224 if (!SWIG_IsOK(res2)) {
29225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29226 }
29227 arg2 = reinterpret_cast< wxColour * >(argp2);
29228 if (arg1) (arg1)->colBg = *arg2;
29229
29230 resultobj = SWIG_Py_Void();
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29238 PyObject *resultobj = 0;
29239 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29240 wxColour *result = 0 ;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 PyObject *swig_obj[1] ;
29244
29245 if (!args) SWIG_fail;
29246 swig_obj[0] = args;
29247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29248 if (!SWIG_IsOK(res1)) {
29249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29250 }
29251 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29252 result = (wxColour *)& ((arg1)->colBg);
29253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29261 PyObject *obj;
29262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29263 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29264 return SWIG_Py_Void();
29265 }
29266
29267 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29268 return SWIG_Python_InitShadowInstance(args);
29269 }
29270
29271 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj = 0;
29273 wxWindow *arg1 = (wxWindow *) 0 ;
29274 int arg2 = (int) (int)-1 ;
29275 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29276 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29277 wxSize const &arg4_defvalue = wxDefaultSize ;
29278 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29279 long arg5 = (long) 0 ;
29280 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29281 wxString *arg6 = (wxString *) &arg6_defvalue ;
29282 wxWindow *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 int val2 ;
29286 int ecode2 = 0 ;
29287 wxPoint temp3 ;
29288 wxSize temp4 ;
29289 long val5 ;
29290 int ecode5 = 0 ;
29291 bool temp6 = false ;
29292 PyObject * obj0 = 0 ;
29293 PyObject * obj1 = 0 ;
29294 PyObject * obj2 = 0 ;
29295 PyObject * obj3 = 0 ;
29296 PyObject * obj4 = 0 ;
29297 PyObject * obj5 = 0 ;
29298 char * kwnames[] = {
29299 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29300 };
29301
29302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29306 }
29307 arg1 = reinterpret_cast< wxWindow * >(argp1);
29308 if (obj1) {
29309 ecode2 = SWIG_AsVal_int(obj1, &val2);
29310 if (!SWIG_IsOK(ecode2)) {
29311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29312 }
29313 arg2 = static_cast< int >(val2);
29314 }
29315 if (obj2) {
29316 {
29317 arg3 = &temp3;
29318 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29319 }
29320 }
29321 if (obj3) {
29322 {
29323 arg4 = &temp4;
29324 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29325 }
29326 }
29327 if (obj4) {
29328 ecode5 = SWIG_AsVal_long(obj4, &val5);
29329 if (!SWIG_IsOK(ecode5)) {
29330 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29331 }
29332 arg5 = static_cast< long >(val5);
29333 }
29334 if (obj5) {
29335 {
29336 arg6 = wxString_in_helper(obj5);
29337 if (arg6 == NULL) SWIG_fail;
29338 temp6 = true;
29339 }
29340 }
29341 {
29342 if (!wxPyCheckForApp()) SWIG_fail;
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29349 {
29350 if (temp6)
29351 delete arg6;
29352 }
29353 return resultobj;
29354 fail:
29355 {
29356 if (temp6)
29357 delete arg6;
29358 }
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29364 PyObject *resultobj = 0;
29365 wxWindow *result = 0 ;
29366
29367 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29368 {
29369 if (!wxPyCheckForApp()) SWIG_fail;
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 result = (wxWindow *)new wxWindow();
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29383 PyObject *resultobj = 0;
29384 wxWindow *arg1 = (wxWindow *) 0 ;
29385 wxWindow *arg2 = (wxWindow *) 0 ;
29386 int arg3 = (int) (int)-1 ;
29387 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29388 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29389 wxSize const &arg5_defvalue = wxDefaultSize ;
29390 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29391 long arg6 = (long) 0 ;
29392 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29393 wxString *arg7 = (wxString *) &arg7_defvalue ;
29394 bool result;
29395 void *argp1 = 0 ;
29396 int res1 = 0 ;
29397 void *argp2 = 0 ;
29398 int res2 = 0 ;
29399 int val3 ;
29400 int ecode3 = 0 ;
29401 wxPoint temp4 ;
29402 wxSize temp5 ;
29403 long val6 ;
29404 int ecode6 = 0 ;
29405 bool temp7 = false ;
29406 PyObject * obj0 = 0 ;
29407 PyObject * obj1 = 0 ;
29408 PyObject * obj2 = 0 ;
29409 PyObject * obj3 = 0 ;
29410 PyObject * obj4 = 0 ;
29411 PyObject * obj5 = 0 ;
29412 PyObject * obj6 = 0 ;
29413 char * kwnames[] = {
29414 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29415 };
29416
29417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29419 if (!SWIG_IsOK(res1)) {
29420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29421 }
29422 arg1 = reinterpret_cast< wxWindow * >(argp1);
29423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29424 if (!SWIG_IsOK(res2)) {
29425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29426 }
29427 arg2 = reinterpret_cast< wxWindow * >(argp2);
29428 if (obj2) {
29429 ecode3 = SWIG_AsVal_int(obj2, &val3);
29430 if (!SWIG_IsOK(ecode3)) {
29431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29432 }
29433 arg3 = static_cast< int >(val3);
29434 }
29435 if (obj3) {
29436 {
29437 arg4 = &temp4;
29438 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29439 }
29440 }
29441 if (obj4) {
29442 {
29443 arg5 = &temp5;
29444 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29445 }
29446 }
29447 if (obj5) {
29448 ecode6 = SWIG_AsVal_long(obj5, &val6);
29449 if (!SWIG_IsOK(ecode6)) {
29450 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29451 }
29452 arg6 = static_cast< long >(val6);
29453 }
29454 if (obj6) {
29455 {
29456 arg7 = wxString_in_helper(obj6);
29457 if (arg7 == NULL) SWIG_fail;
29458 temp7 = true;
29459 }
29460 }
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 {
29471 if (temp7)
29472 delete arg7;
29473 }
29474 return resultobj;
29475 fail:
29476 {
29477 if (temp7)
29478 delete arg7;
29479 }
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29485 PyObject *resultobj = 0;
29486 wxWindow *arg1 = (wxWindow *) 0 ;
29487 bool arg2 = (bool) false ;
29488 bool result;
29489 void *argp1 = 0 ;
29490 int res1 = 0 ;
29491 bool val2 ;
29492 int ecode2 = 0 ;
29493 PyObject * obj0 = 0 ;
29494 PyObject * obj1 = 0 ;
29495 char * kwnames[] = {
29496 (char *) "self",(char *) "force", NULL
29497 };
29498
29499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29501 if (!SWIG_IsOK(res1)) {
29502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29503 }
29504 arg1 = reinterpret_cast< wxWindow * >(argp1);
29505 if (obj1) {
29506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29507 if (!SWIG_IsOK(ecode2)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29509 }
29510 arg2 = static_cast< bool >(val2);
29511 }
29512 {
29513 PyThreadState* __tstate = wxPyBeginAllowThreads();
29514 result = (bool)(arg1)->Close(arg2);
29515 wxPyEndAllowThreads(__tstate);
29516 if (PyErr_Occurred()) SWIG_fail;
29517 }
29518 {
29519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29520 }
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29528 PyObject *resultobj = 0;
29529 wxWindow *arg1 = (wxWindow *) 0 ;
29530 bool result;
29531 void *argp1 = 0 ;
29532 int res1 = 0 ;
29533 PyObject *swig_obj[1] ;
29534
29535 if (!args) SWIG_fail;
29536 swig_obj[0] = args;
29537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29538 if (!SWIG_IsOK(res1)) {
29539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29540 }
29541 arg1 = reinterpret_cast< wxWindow * >(argp1);
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = (bool)(arg1)->Destroy();
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 {
29549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29550 }
29551 return resultobj;
29552 fail:
29553 return NULL;
29554 }
29555
29556
29557 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29558 PyObject *resultobj = 0;
29559 wxWindow *arg1 = (wxWindow *) 0 ;
29560 bool result;
29561 void *argp1 = 0 ;
29562 int res1 = 0 ;
29563 PyObject *swig_obj[1] ;
29564
29565 if (!args) SWIG_fail;
29566 swig_obj[0] = args;
29567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29570 }
29571 arg1 = reinterpret_cast< wxWindow * >(argp1);
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = (bool)(arg1)->DestroyChildren();
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 {
29579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29580 }
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29588 PyObject *resultobj = 0;
29589 wxWindow *arg1 = (wxWindow *) 0 ;
29590 bool result;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 PyObject *swig_obj[1] ;
29594
29595 if (!args) SWIG_fail;
29596 swig_obj[0] = args;
29597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29598 if (!SWIG_IsOK(res1)) {
29599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29600 }
29601 arg1 = reinterpret_cast< wxWindow * >(argp1);
29602 {
29603 PyThreadState* __tstate = wxPyBeginAllowThreads();
29604 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29605 wxPyEndAllowThreads(__tstate);
29606 if (PyErr_Occurred()) SWIG_fail;
29607 }
29608 {
29609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29610 }
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj = 0;
29619 wxWindow *arg1 = (wxWindow *) 0 ;
29620 wxString *arg2 = 0 ;
29621 void *argp1 = 0 ;
29622 int res1 = 0 ;
29623 bool temp2 = false ;
29624 PyObject * obj0 = 0 ;
29625 PyObject * obj1 = 0 ;
29626 char * kwnames[] = {
29627 (char *) "self",(char *) "label", NULL
29628 };
29629
29630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29632 if (!SWIG_IsOK(res1)) {
29633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29634 }
29635 arg1 = reinterpret_cast< wxWindow * >(argp1);
29636 {
29637 arg2 = wxString_in_helper(obj1);
29638 if (arg2 == NULL) SWIG_fail;
29639 temp2 = true;
29640 }
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 (arg1)->SetLabel((wxString const &)*arg2);
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 resultobj = SWIG_Py_Void();
29648 {
29649 if (temp2)
29650 delete arg2;
29651 }
29652 return resultobj;
29653 fail:
29654 {
29655 if (temp2)
29656 delete arg2;
29657 }
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29663 PyObject *resultobj = 0;
29664 wxWindow *arg1 = (wxWindow *) 0 ;
29665 wxString result;
29666 void *argp1 = 0 ;
29667 int res1 = 0 ;
29668 PyObject *swig_obj[1] ;
29669
29670 if (!args) SWIG_fail;
29671 swig_obj[0] = args;
29672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29675 }
29676 arg1 = reinterpret_cast< wxWindow * >(argp1);
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 result = ((wxWindow const *)arg1)->GetLabel();
29680 wxPyEndAllowThreads(__tstate);
29681 if (PyErr_Occurred()) SWIG_fail;
29682 }
29683 {
29684 #if wxUSE_UNICODE
29685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29686 #else
29687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29688 #endif
29689 }
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj = 0;
29698 wxWindow *arg1 = (wxWindow *) 0 ;
29699 wxString *arg2 = 0 ;
29700 void *argp1 = 0 ;
29701 int res1 = 0 ;
29702 bool temp2 = false ;
29703 PyObject * obj0 = 0 ;
29704 PyObject * obj1 = 0 ;
29705 char * kwnames[] = {
29706 (char *) "self",(char *) "name", NULL
29707 };
29708
29709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29711 if (!SWIG_IsOK(res1)) {
29712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29713 }
29714 arg1 = reinterpret_cast< wxWindow * >(argp1);
29715 {
29716 arg2 = wxString_in_helper(obj1);
29717 if (arg2 == NULL) SWIG_fail;
29718 temp2 = true;
29719 }
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 (arg1)->SetName((wxString const &)*arg2);
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 resultobj = SWIG_Py_Void();
29727 {
29728 if (temp2)
29729 delete arg2;
29730 }
29731 return resultobj;
29732 fail:
29733 {
29734 if (temp2)
29735 delete arg2;
29736 }
29737 return NULL;
29738 }
29739
29740
29741 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29742 PyObject *resultobj = 0;
29743 wxWindow *arg1 = (wxWindow *) 0 ;
29744 wxString result;
29745 void *argp1 = 0 ;
29746 int res1 = 0 ;
29747 PyObject *swig_obj[1] ;
29748
29749 if (!args) SWIG_fail;
29750 swig_obj[0] = args;
29751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29752 if (!SWIG_IsOK(res1)) {
29753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29754 }
29755 arg1 = reinterpret_cast< wxWindow * >(argp1);
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 result = ((wxWindow const *)arg1)->GetName();
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 {
29763 #if wxUSE_UNICODE
29764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29765 #else
29766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29767 #endif
29768 }
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29776 PyObject *resultobj = 0;
29777 wxWindow *arg1 = (wxWindow *) 0 ;
29778 wxWindowVariant arg2 ;
29779 void *argp1 = 0 ;
29780 int res1 = 0 ;
29781 int val2 ;
29782 int ecode2 = 0 ;
29783 PyObject * obj0 = 0 ;
29784 PyObject * obj1 = 0 ;
29785 char * kwnames[] = {
29786 (char *) "self",(char *) "variant", NULL
29787 };
29788
29789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29791 if (!SWIG_IsOK(res1)) {
29792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29793 }
29794 arg1 = reinterpret_cast< wxWindow * >(argp1);
29795 ecode2 = SWIG_AsVal_int(obj1, &val2);
29796 if (!SWIG_IsOK(ecode2)) {
29797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29798 }
29799 arg2 = static_cast< wxWindowVariant >(val2);
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 (arg1)->SetWindowVariant(arg2);
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 resultobj = SWIG_Py_Void();
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29814 PyObject *resultobj = 0;
29815 wxWindow *arg1 = (wxWindow *) 0 ;
29816 wxWindowVariant result;
29817 void *argp1 = 0 ;
29818 int res1 = 0 ;
29819 PyObject *swig_obj[1] ;
29820
29821 if (!args) SWIG_fail;
29822 swig_obj[0] = args;
29823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29824 if (!SWIG_IsOK(res1)) {
29825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29826 }
29827 arg1 = reinterpret_cast< wxWindow * >(argp1);
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 resultobj = SWIG_From_int(static_cast< int >(result));
29835 return resultobj;
29836 fail:
29837 return NULL;
29838 }
29839
29840
29841 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29842 PyObject *resultobj = 0;
29843 wxWindow *arg1 = (wxWindow *) 0 ;
29844 int arg2 ;
29845 void *argp1 = 0 ;
29846 int res1 = 0 ;
29847 int val2 ;
29848 int ecode2 = 0 ;
29849 PyObject * obj0 = 0 ;
29850 PyObject * obj1 = 0 ;
29851 char * kwnames[] = {
29852 (char *) "self",(char *) "winid", NULL
29853 };
29854
29855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29857 if (!SWIG_IsOK(res1)) {
29858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29859 }
29860 arg1 = reinterpret_cast< wxWindow * >(argp1);
29861 ecode2 = SWIG_AsVal_int(obj1, &val2);
29862 if (!SWIG_IsOK(ecode2)) {
29863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29864 }
29865 arg2 = static_cast< int >(val2);
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 (arg1)->SetId(arg2);
29869 wxPyEndAllowThreads(__tstate);
29870 if (PyErr_Occurred()) SWIG_fail;
29871 }
29872 resultobj = SWIG_Py_Void();
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29880 PyObject *resultobj = 0;
29881 wxWindow *arg1 = (wxWindow *) 0 ;
29882 int result;
29883 void *argp1 = 0 ;
29884 int res1 = 0 ;
29885 PyObject *swig_obj[1] ;
29886
29887 if (!args) SWIG_fail;
29888 swig_obj[0] = args;
29889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29890 if (!SWIG_IsOK(res1)) {
29891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29892 }
29893 arg1 = reinterpret_cast< wxWindow * >(argp1);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 result = (int)((wxWindow const *)arg1)->GetId();
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_From_int(static_cast< int >(result));
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 int result;
29910
29911 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (int)wxWindow::NewControlId();
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_From_int(static_cast< int >(result));
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj = 0;
29927 int arg1 ;
29928 int result;
29929 int val1 ;
29930 int ecode1 = 0 ;
29931 PyObject * obj0 = 0 ;
29932 char * kwnames[] = {
29933 (char *) "winid", NULL
29934 };
29935
29936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29937 ecode1 = SWIG_AsVal_int(obj0, &val1);
29938 if (!SWIG_IsOK(ecode1)) {
29939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29940 }
29941 arg1 = static_cast< int >(val1);
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = (int)wxWindow::NextControlId(arg1);
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_From_int(static_cast< int >(result));
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj = 0;
29957 int arg1 ;
29958 int result;
29959 int val1 ;
29960 int ecode1 = 0 ;
29961 PyObject * obj0 = 0 ;
29962 char * kwnames[] = {
29963 (char *) "winid", NULL
29964 };
29965
29966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29967 ecode1 = SWIG_AsVal_int(obj0, &val1);
29968 if (!SWIG_IsOK(ecode1)) {
29969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29970 }
29971 arg1 = static_cast< int >(val1);
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 result = (int)wxWindow::PrevControlId(arg1);
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 resultobj = SWIG_From_int(static_cast< int >(result));
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29986 PyObject *resultobj = 0;
29987 wxWindow *arg1 = (wxWindow *) 0 ;
29988 wxSize *arg2 = 0 ;
29989 void *argp1 = 0 ;
29990 int res1 = 0 ;
29991 wxSize temp2 ;
29992 PyObject * obj0 = 0 ;
29993 PyObject * obj1 = 0 ;
29994 char * kwnames[] = {
29995 (char *) "self",(char *) "size", NULL
29996 };
29997
29998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
29999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30000 if (!SWIG_IsOK(res1)) {
30001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30002 }
30003 arg1 = reinterpret_cast< wxWindow * >(argp1);
30004 {
30005 arg2 = &temp2;
30006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30007 }
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 (arg1)->SetSize((wxSize const &)*arg2);
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_Py_Void();
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj = 0;
30023 wxWindow *arg1 = (wxWindow *) 0 ;
30024 int arg2 ;
30025 int arg3 ;
30026 int arg4 ;
30027 int arg5 ;
30028 int arg6 = (int) wxSIZE_AUTO ;
30029 void *argp1 = 0 ;
30030 int res1 = 0 ;
30031 int val2 ;
30032 int ecode2 = 0 ;
30033 int val3 ;
30034 int ecode3 = 0 ;
30035 int val4 ;
30036 int ecode4 = 0 ;
30037 int val5 ;
30038 int ecode5 = 0 ;
30039 int val6 ;
30040 int ecode6 = 0 ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 PyObject * obj2 = 0 ;
30044 PyObject * obj3 = 0 ;
30045 PyObject * obj4 = 0 ;
30046 PyObject * obj5 = 0 ;
30047 char * kwnames[] = {
30048 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30049 };
30050
30051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30055 }
30056 arg1 = reinterpret_cast< wxWindow * >(argp1);
30057 ecode2 = SWIG_AsVal_int(obj1, &val2);
30058 if (!SWIG_IsOK(ecode2)) {
30059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30060 }
30061 arg2 = static_cast< int >(val2);
30062 ecode3 = SWIG_AsVal_int(obj2, &val3);
30063 if (!SWIG_IsOK(ecode3)) {
30064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30065 }
30066 arg3 = static_cast< int >(val3);
30067 ecode4 = SWIG_AsVal_int(obj3, &val4);
30068 if (!SWIG_IsOK(ecode4)) {
30069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30070 }
30071 arg4 = static_cast< int >(val4);
30072 ecode5 = SWIG_AsVal_int(obj4, &val5);
30073 if (!SWIG_IsOK(ecode5)) {
30074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30075 }
30076 arg5 = static_cast< int >(val5);
30077 if (obj5) {
30078 ecode6 = SWIG_AsVal_int(obj5, &val6);
30079 if (!SWIG_IsOK(ecode6)) {
30080 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30081 }
30082 arg6 = static_cast< int >(val6);
30083 }
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 resultobj = SWIG_Py_Void();
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj = 0;
30099 wxWindow *arg1 = (wxWindow *) 0 ;
30100 wxRect *arg2 = 0 ;
30101 int arg3 = (int) wxSIZE_AUTO ;
30102 void *argp1 = 0 ;
30103 int res1 = 0 ;
30104 wxRect temp2 ;
30105 int val3 ;
30106 int ecode3 = 0 ;
30107 PyObject * obj0 = 0 ;
30108 PyObject * obj1 = 0 ;
30109 PyObject * obj2 = 0 ;
30110 char * kwnames[] = {
30111 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30112 };
30113
30114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30116 if (!SWIG_IsOK(res1)) {
30117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30118 }
30119 arg1 = reinterpret_cast< wxWindow * >(argp1);
30120 {
30121 arg2 = &temp2;
30122 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30123 }
30124 if (obj2) {
30125 ecode3 = SWIG_AsVal_int(obj2, &val3);
30126 if (!SWIG_IsOK(ecode3)) {
30127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30128 }
30129 arg3 = static_cast< int >(val3);
30130 }
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 resultobj = SWIG_Py_Void();
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30145 PyObject *resultobj = 0;
30146 wxWindow *arg1 = (wxWindow *) 0 ;
30147 int arg2 ;
30148 int arg3 ;
30149 void *argp1 = 0 ;
30150 int res1 = 0 ;
30151 int val2 ;
30152 int ecode2 = 0 ;
30153 int val3 ;
30154 int ecode3 = 0 ;
30155 PyObject * obj0 = 0 ;
30156 PyObject * obj1 = 0 ;
30157 PyObject * obj2 = 0 ;
30158 char * kwnames[] = {
30159 (char *) "self",(char *) "width",(char *) "height", NULL
30160 };
30161
30162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30164 if (!SWIG_IsOK(res1)) {
30165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30166 }
30167 arg1 = reinterpret_cast< wxWindow * >(argp1);
30168 ecode2 = SWIG_AsVal_int(obj1, &val2);
30169 if (!SWIG_IsOK(ecode2)) {
30170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30171 }
30172 arg2 = static_cast< int >(val2);
30173 ecode3 = SWIG_AsVal_int(obj2, &val3);
30174 if (!SWIG_IsOK(ecode3)) {
30175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30176 }
30177 arg3 = static_cast< int >(val3);
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 (arg1)->SetSize(arg2,arg3);
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_Py_Void();
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 wxWindow *arg1 = (wxWindow *) 0 ;
30194 wxPoint *arg2 = 0 ;
30195 int arg3 = (int) wxSIZE_USE_EXISTING ;
30196 void *argp1 = 0 ;
30197 int res1 = 0 ;
30198 wxPoint temp2 ;
30199 int val3 ;
30200 int ecode3 = 0 ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 PyObject * obj2 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "pt",(char *) "flags", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30212 }
30213 arg1 = reinterpret_cast< wxWindow * >(argp1);
30214 {
30215 arg2 = &temp2;
30216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30217 }
30218 if (obj2) {
30219 ecode3 = SWIG_AsVal_int(obj2, &val3);
30220 if (!SWIG_IsOK(ecode3)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30222 }
30223 arg3 = static_cast< int >(val3);
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 (arg1)->Move((wxPoint const &)*arg2,arg3);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_Py_Void();
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj = 0;
30240 wxWindow *arg1 = (wxWindow *) 0 ;
30241 int arg2 ;
30242 int arg3 ;
30243 int arg4 = (int) wxSIZE_USE_EXISTING ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 int val2 ;
30247 int ecode2 = 0 ;
30248 int val3 ;
30249 int ecode3 = 0 ;
30250 int val4 ;
30251 int ecode4 = 0 ;
30252 PyObject * obj0 = 0 ;
30253 PyObject * obj1 = 0 ;
30254 PyObject * obj2 = 0 ;
30255 PyObject * obj3 = 0 ;
30256 char * kwnames[] = {
30257 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30258 };
30259
30260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30262 if (!SWIG_IsOK(res1)) {
30263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30264 }
30265 arg1 = reinterpret_cast< wxWindow * >(argp1);
30266 ecode2 = SWIG_AsVal_int(obj1, &val2);
30267 if (!SWIG_IsOK(ecode2)) {
30268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30269 }
30270 arg2 = static_cast< int >(val2);
30271 ecode3 = SWIG_AsVal_int(obj2, &val3);
30272 if (!SWIG_IsOK(ecode3)) {
30273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30274 }
30275 arg3 = static_cast< int >(val3);
30276 if (obj3) {
30277 ecode4 = SWIG_AsVal_int(obj3, &val4);
30278 if (!SWIG_IsOK(ecode4)) {
30279 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30280 }
30281 arg4 = static_cast< int >(val4);
30282 }
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 (arg1)->Move(arg2,arg3,arg4);
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 resultobj = SWIG_Py_Void();
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30297 PyObject *resultobj = 0;
30298 wxWindow *arg1 = (wxWindow *) 0 ;
30299 wxSize const &arg2_defvalue = wxDefaultSize ;
30300 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30301 void *argp1 = 0 ;
30302 int res1 = 0 ;
30303 wxSize temp2 ;
30304 PyObject * obj0 = 0 ;
30305 PyObject * obj1 = 0 ;
30306 char * kwnames[] = {
30307 (char *) "self",(char *) "size", NULL
30308 };
30309
30310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30314 }
30315 arg1 = reinterpret_cast< wxWindow * >(argp1);
30316 if (obj1) {
30317 {
30318 arg2 = &temp2;
30319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30320 }
30321 }
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 resultobj = SWIG_Py_Void();
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30336 PyObject *resultobj = 0;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 PyObject *swig_obj[1] ;
30341
30342 if (!args) SWIG_fail;
30343 swig_obj[0] = args;
30344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30345 if (!SWIG_IsOK(res1)) {
30346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30347 }
30348 arg1 = reinterpret_cast< wxWindow * >(argp1);
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 (arg1)->Raise();
30352 wxPyEndAllowThreads(__tstate);
30353 if (PyErr_Occurred()) SWIG_fail;
30354 }
30355 resultobj = SWIG_Py_Void();
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30363 PyObject *resultobj = 0;
30364 wxWindow *arg1 = (wxWindow *) 0 ;
30365 void *argp1 = 0 ;
30366 int res1 = 0 ;
30367 PyObject *swig_obj[1] ;
30368
30369 if (!args) SWIG_fail;
30370 swig_obj[0] = args;
30371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30372 if (!SWIG_IsOK(res1)) {
30373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30374 }
30375 arg1 = reinterpret_cast< wxWindow * >(argp1);
30376 {
30377 PyThreadState* __tstate = wxPyBeginAllowThreads();
30378 (arg1)->Lower();
30379 wxPyEndAllowThreads(__tstate);
30380 if (PyErr_Occurred()) SWIG_fail;
30381 }
30382 resultobj = SWIG_Py_Void();
30383 return resultobj;
30384 fail:
30385 return NULL;
30386 }
30387
30388
30389 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30390 PyObject *resultobj = 0;
30391 wxWindow *arg1 = (wxWindow *) 0 ;
30392 wxSize *arg2 = 0 ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 wxSize temp2 ;
30396 PyObject * obj0 = 0 ;
30397 PyObject * obj1 = 0 ;
30398 char * kwnames[] = {
30399 (char *) "self",(char *) "size", NULL
30400 };
30401
30402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30404 if (!SWIG_IsOK(res1)) {
30405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30406 }
30407 arg1 = reinterpret_cast< wxWindow * >(argp1);
30408 {
30409 arg2 = &temp2;
30410 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30411 }
30412 {
30413 PyThreadState* __tstate = wxPyBeginAllowThreads();
30414 (arg1)->SetClientSize((wxSize const &)*arg2);
30415 wxPyEndAllowThreads(__tstate);
30416 if (PyErr_Occurred()) SWIG_fail;
30417 }
30418 resultobj = SWIG_Py_Void();
30419 return resultobj;
30420 fail:
30421 return NULL;
30422 }
30423
30424
30425 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30426 PyObject *resultobj = 0;
30427 wxWindow *arg1 = (wxWindow *) 0 ;
30428 int arg2 ;
30429 int arg3 ;
30430 void *argp1 = 0 ;
30431 int res1 = 0 ;
30432 int val2 ;
30433 int ecode2 = 0 ;
30434 int val3 ;
30435 int ecode3 = 0 ;
30436 PyObject * obj0 = 0 ;
30437 PyObject * obj1 = 0 ;
30438 PyObject * obj2 = 0 ;
30439 char * kwnames[] = {
30440 (char *) "self",(char *) "width",(char *) "height", NULL
30441 };
30442
30443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30447 }
30448 arg1 = reinterpret_cast< wxWindow * >(argp1);
30449 ecode2 = SWIG_AsVal_int(obj1, &val2);
30450 if (!SWIG_IsOK(ecode2)) {
30451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30452 }
30453 arg2 = static_cast< int >(val2);
30454 ecode3 = SWIG_AsVal_int(obj2, &val3);
30455 if (!SWIG_IsOK(ecode3)) {
30456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30457 }
30458 arg3 = static_cast< int >(val3);
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 (arg1)->SetClientSize(arg2,arg3);
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 resultobj = SWIG_Py_Void();
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj = 0;
30474 wxWindow *arg1 = (wxWindow *) 0 ;
30475 wxRect *arg2 = 0 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 wxRect temp2 ;
30479 PyObject * obj0 = 0 ;
30480 PyObject * obj1 = 0 ;
30481 char * kwnames[] = {
30482 (char *) "self",(char *) "rect", NULL
30483 };
30484
30485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30487 if (!SWIG_IsOK(res1)) {
30488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30489 }
30490 arg1 = reinterpret_cast< wxWindow * >(argp1);
30491 {
30492 arg2 = &temp2;
30493 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30494 }
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 (arg1)->SetClientSize((wxRect const &)*arg2);
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 resultobj = SWIG_Py_Void();
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30509 PyObject *resultobj = 0;
30510 wxWindow *arg1 = (wxWindow *) 0 ;
30511 wxPoint result;
30512 void *argp1 = 0 ;
30513 int res1 = 0 ;
30514 PyObject *swig_obj[1] ;
30515
30516 if (!args) SWIG_fail;
30517 swig_obj[0] = args;
30518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30519 if (!SWIG_IsOK(res1)) {
30520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow *""'");
30521 }
30522 arg1 = reinterpret_cast< wxWindow * >(argp1);
30523 {
30524 PyThreadState* __tstate = wxPyBeginAllowThreads();
30525 result = (arg1)->GetPosition();
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30537 PyObject *resultobj = 0;
30538 wxWindow *arg1 = (wxWindow *) 0 ;
30539 int *arg2 = (int *) 0 ;
30540 int *arg3 = (int *) 0 ;
30541 void *argp1 = 0 ;
30542 int res1 = 0 ;
30543 int temp2 ;
30544 int res2 = SWIG_TMPOBJ ;
30545 int temp3 ;
30546 int res3 = SWIG_TMPOBJ ;
30547 PyObject *swig_obj[1] ;
30548
30549 arg2 = &temp2;
30550 arg3 = &temp3;
30551 if (!args) SWIG_fail;
30552 swig_obj[0] = args;
30553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30554 if (!SWIG_IsOK(res1)) {
30555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow *""'");
30556 }
30557 arg1 = reinterpret_cast< wxWindow * >(argp1);
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 (arg1)->GetPosition(arg2,arg3);
30561 wxPyEndAllowThreads(__tstate);
30562 if (PyErr_Occurred()) SWIG_fail;
30563 }
30564 resultobj = SWIG_Py_Void();
30565 if (SWIG_IsTmpObj(res2)) {
30566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30567 } else {
30568 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30570 }
30571 if (SWIG_IsTmpObj(res3)) {
30572 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30573 } else {
30574 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30576 }
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *resultobj = 0;
30585 wxWindow *arg1 = (wxWindow *) 0 ;
30586 wxSize result;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 PyObject *swig_obj[1] ;
30590
30591 if (!args) SWIG_fail;
30592 swig_obj[0] = args;
30593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30596 }
30597 arg1 = reinterpret_cast< wxWindow * >(argp1);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = ((wxWindow const *)arg1)->GetSize();
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30612 PyObject *resultobj = 0;
30613 wxWindow *arg1 = (wxWindow *) 0 ;
30614 int *arg2 = (int *) 0 ;
30615 int *arg3 = (int *) 0 ;
30616 void *argp1 = 0 ;
30617 int res1 = 0 ;
30618 int temp2 ;
30619 int res2 = SWIG_TMPOBJ ;
30620 int temp3 ;
30621 int res3 = SWIG_TMPOBJ ;
30622 PyObject *swig_obj[1] ;
30623
30624 arg2 = &temp2;
30625 arg3 = &temp3;
30626 if (!args) SWIG_fail;
30627 swig_obj[0] = args;
30628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30631 }
30632 arg1 = reinterpret_cast< wxWindow * >(argp1);
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_Py_Void();
30640 if (SWIG_IsTmpObj(res2)) {
30641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30642 } else {
30643 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30645 }
30646 if (SWIG_IsTmpObj(res3)) {
30647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30648 } else {
30649 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30651 }
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 PyObject *resultobj = 0;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 wxRect result;
30662 void *argp1 = 0 ;
30663 int res1 = 0 ;
30664 PyObject *swig_obj[1] ;
30665
30666 if (!args) SWIG_fail;
30667 swig_obj[0] = args;
30668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30669 if (!SWIG_IsOK(res1)) {
30670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30671 }
30672 arg1 = reinterpret_cast< wxWindow * >(argp1);
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 result = ((wxWindow const *)arg1)->GetRect();
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 wxSize result;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 PyObject *swig_obj[1] ;
30693
30694 if (!args) SWIG_fail;
30695 swig_obj[0] = args;
30696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30699 }
30700 arg1 = reinterpret_cast< wxWindow * >(argp1);
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = ((wxWindow const *)arg1)->GetClientSize();
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30708 return resultobj;
30709 fail:
30710 return NULL;
30711 }
30712
30713
30714 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30715 PyObject *resultobj = 0;
30716 wxWindow *arg1 = (wxWindow *) 0 ;
30717 int *arg2 = (int *) 0 ;
30718 int *arg3 = (int *) 0 ;
30719 void *argp1 = 0 ;
30720 int res1 = 0 ;
30721 int temp2 ;
30722 int res2 = SWIG_TMPOBJ ;
30723 int temp3 ;
30724 int res3 = SWIG_TMPOBJ ;
30725 PyObject *swig_obj[1] ;
30726
30727 arg2 = &temp2;
30728 arg3 = &temp3;
30729 if (!args) SWIG_fail;
30730 swig_obj[0] = args;
30731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxWindow * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_Py_Void();
30743 if (SWIG_IsTmpObj(res2)) {
30744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30745 } else {
30746 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30748 }
30749 if (SWIG_IsTmpObj(res3)) {
30750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30751 } else {
30752 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30754 }
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30762 PyObject *resultobj = 0;
30763 wxWindow *arg1 = (wxWindow *) 0 ;
30764 wxPoint result;
30765 void *argp1 = 0 ;
30766 int res1 = 0 ;
30767 PyObject *swig_obj[1] ;
30768
30769 if (!args) SWIG_fail;
30770 swig_obj[0] = args;
30771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30772 if (!SWIG_IsOK(res1)) {
30773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30774 }
30775 arg1 = reinterpret_cast< wxWindow * >(argp1);
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30790 PyObject *resultobj = 0;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 wxRect result;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 PyObject *swig_obj[1] ;
30796
30797 if (!args) SWIG_fail;
30798 swig_obj[0] = args;
30799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30800 if (!SWIG_IsOK(res1)) {
30801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30802 }
30803 arg1 = reinterpret_cast< wxWindow * >(argp1);
30804 {
30805 PyThreadState* __tstate = wxPyBeginAllowThreads();
30806 result = ((wxWindow const *)arg1)->GetClientRect();
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30818 PyObject *resultobj = 0;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 wxSize result;
30821 void *argp1 = 0 ;
30822 int res1 = 0 ;
30823 PyObject *swig_obj[1] ;
30824
30825 if (!args) SWIG_fail;
30826 swig_obj[0] = args;
30827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30828 if (!SWIG_IsOK(res1)) {
30829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30830 }
30831 arg1 = reinterpret_cast< wxWindow * >(argp1);
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 result = ((wxWindow const *)arg1)->GetBestSize();
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30846 PyObject *resultobj = 0;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 int *arg2 = (int *) 0 ;
30849 int *arg3 = (int *) 0 ;
30850 void *argp1 = 0 ;
30851 int res1 = 0 ;
30852 int temp2 ;
30853 int res2 = SWIG_TMPOBJ ;
30854 int temp3 ;
30855 int res3 = SWIG_TMPOBJ ;
30856 PyObject *swig_obj[1] ;
30857
30858 arg2 = &temp2;
30859 arg3 = &temp3;
30860 if (!args) SWIG_fail;
30861 swig_obj[0] = args;
30862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30863 if (!SWIG_IsOK(res1)) {
30864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30865 }
30866 arg1 = reinterpret_cast< wxWindow * >(argp1);
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 resultobj = SWIG_Py_Void();
30874 if (SWIG_IsTmpObj(res2)) {
30875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30876 } else {
30877 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30879 }
30880 if (SWIG_IsTmpObj(res3)) {
30881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30882 } else {
30883 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30885 }
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30893 PyObject *resultobj = 0;
30894 wxWindow *arg1 = (wxWindow *) 0 ;
30895 void *argp1 = 0 ;
30896 int res1 = 0 ;
30897 PyObject *swig_obj[1] ;
30898
30899 if (!args) SWIG_fail;
30900 swig_obj[0] = args;
30901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30902 if (!SWIG_IsOK(res1)) {
30903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30904 }
30905 arg1 = reinterpret_cast< wxWindow * >(argp1);
30906 {
30907 PyThreadState* __tstate = wxPyBeginAllowThreads();
30908 (arg1)->InvalidateBestSize();
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 resultobj = SWIG_Py_Void();
30913 return resultobj;
30914 fail:
30915 return NULL;
30916 }
30917
30918
30919 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30920 PyObject *resultobj = 0;
30921 wxWindow *arg1 = (wxWindow *) 0 ;
30922 wxSize *arg2 = 0 ;
30923 void *argp1 = 0 ;
30924 int res1 = 0 ;
30925 wxSize temp2 ;
30926 PyObject * obj0 = 0 ;
30927 PyObject * obj1 = 0 ;
30928 char * kwnames[] = {
30929 (char *) "self",(char *) "size", NULL
30930 };
30931
30932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
30933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30934 if (!SWIG_IsOK(res1)) {
30935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30936 }
30937 arg1 = reinterpret_cast< wxWindow * >(argp1);
30938 {
30939 arg2 = &temp2;
30940 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30941 }
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 resultobj = SWIG_Py_Void();
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30956 PyObject *resultobj = 0;
30957 wxWindow *arg1 = (wxWindow *) 0 ;
30958 wxSize result;
30959 void *argp1 = 0 ;
30960 int res1 = 0 ;
30961 PyObject *swig_obj[1] ;
30962
30963 if (!args) SWIG_fail;
30964 swig_obj[0] = args;
30965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30966 if (!SWIG_IsOK(res1)) {
30967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30968 }
30969 arg1 = reinterpret_cast< wxWindow * >(argp1);
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 result = ((wxWindow const *)arg1)->GetBestFittingSize();
30973 wxPyEndAllowThreads(__tstate);
30974 if (PyErr_Occurred()) SWIG_fail;
30975 }
30976 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30977 return resultobj;
30978 fail:
30979 return NULL;
30980 }
30981
30982
30983 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30984 PyObject *resultobj = 0;
30985 wxWindow *arg1 = (wxWindow *) 0 ;
30986 wxSize result;
30987 void *argp1 = 0 ;
30988 int res1 = 0 ;
30989 PyObject *swig_obj[1] ;
30990
30991 if (!args) SWIG_fail;
30992 swig_obj[0] = args;
30993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30994 if (!SWIG_IsOK(res1)) {
30995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30996 }
30997 arg1 = reinterpret_cast< wxWindow * >(argp1);
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31001 wxPyEndAllowThreads(__tstate);
31002 if (PyErr_Occurred()) SWIG_fail;
31003 }
31004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31005 return resultobj;
31006 fail:
31007 return NULL;
31008 }
31009
31010
31011 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31012 PyObject *resultobj = 0;
31013 wxWindow *arg1 = (wxWindow *) 0 ;
31014 int arg2 = (int) wxBOTH ;
31015 void *argp1 = 0 ;
31016 int res1 = 0 ;
31017 int val2 ;
31018 int ecode2 = 0 ;
31019 PyObject * obj0 = 0 ;
31020 PyObject * obj1 = 0 ;
31021 char * kwnames[] = {
31022 (char *) "self",(char *) "direction", NULL
31023 };
31024
31025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31027 if (!SWIG_IsOK(res1)) {
31028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31029 }
31030 arg1 = reinterpret_cast< wxWindow * >(argp1);
31031 if (obj1) {
31032 ecode2 = SWIG_AsVal_int(obj1, &val2);
31033 if (!SWIG_IsOK(ecode2)) {
31034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31035 }
31036 arg2 = static_cast< int >(val2);
31037 }
31038 {
31039 PyThreadState* __tstate = wxPyBeginAllowThreads();
31040 (arg1)->Center(arg2);
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 resultobj = SWIG_Py_Void();
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj = 0;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 int arg2 = (int) wxBOTH ;
31055 void *argp1 = 0 ;
31056 int res1 = 0 ;
31057 int val2 ;
31058 int ecode2 = 0 ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 char * kwnames[] = {
31062 (char *) "self",(char *) "dir", NULL
31063 };
31064
31065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31067 if (!SWIG_IsOK(res1)) {
31068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31069 }
31070 arg1 = reinterpret_cast< wxWindow * >(argp1);
31071 if (obj1) {
31072 ecode2 = SWIG_AsVal_int(obj1, &val2);
31073 if (!SWIG_IsOK(ecode2)) {
31074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31075 }
31076 arg2 = static_cast< int >(val2);
31077 }
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 (arg1)->CenterOnParent(arg2);
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = SWIG_Py_Void();
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31092 PyObject *resultobj = 0;
31093 wxWindow *arg1 = (wxWindow *) 0 ;
31094 void *argp1 = 0 ;
31095 int res1 = 0 ;
31096 PyObject *swig_obj[1] ;
31097
31098 if (!args) SWIG_fail;
31099 swig_obj[0] = args;
31100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31101 if (!SWIG_IsOK(res1)) {
31102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31103 }
31104 arg1 = reinterpret_cast< wxWindow * >(argp1);
31105 {
31106 PyThreadState* __tstate = wxPyBeginAllowThreads();
31107 (arg1)->Fit();
31108 wxPyEndAllowThreads(__tstate);
31109 if (PyErr_Occurred()) SWIG_fail;
31110 }
31111 resultobj = SWIG_Py_Void();
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31119 PyObject *resultobj = 0;
31120 wxWindow *arg1 = (wxWindow *) 0 ;
31121 void *argp1 = 0 ;
31122 int res1 = 0 ;
31123 PyObject *swig_obj[1] ;
31124
31125 if (!args) SWIG_fail;
31126 swig_obj[0] = args;
31127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31128 if (!SWIG_IsOK(res1)) {
31129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31130 }
31131 arg1 = reinterpret_cast< wxWindow * >(argp1);
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 (arg1)->FitInside();
31135 wxPyEndAllowThreads(__tstate);
31136 if (PyErr_Occurred()) SWIG_fail;
31137 }
31138 resultobj = SWIG_Py_Void();
31139 return resultobj;
31140 fail:
31141 return NULL;
31142 }
31143
31144
31145 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31146 PyObject *resultobj = 0;
31147 wxWindow *arg1 = (wxWindow *) 0 ;
31148 int arg2 ;
31149 int arg3 ;
31150 int arg4 = (int) -1 ;
31151 int arg5 = (int) -1 ;
31152 int arg6 = (int) -1 ;
31153 int arg7 = (int) -1 ;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 int val2 ;
31157 int ecode2 = 0 ;
31158 int val3 ;
31159 int ecode3 = 0 ;
31160 int val4 ;
31161 int ecode4 = 0 ;
31162 int val5 ;
31163 int ecode5 = 0 ;
31164 int val6 ;
31165 int ecode6 = 0 ;
31166 int val7 ;
31167 int ecode7 = 0 ;
31168 PyObject * obj0 = 0 ;
31169 PyObject * obj1 = 0 ;
31170 PyObject * obj2 = 0 ;
31171 PyObject * obj3 = 0 ;
31172 PyObject * obj4 = 0 ;
31173 PyObject * obj5 = 0 ;
31174 PyObject * obj6 = 0 ;
31175 char * kwnames[] = {
31176 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31177 };
31178
31179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31183 }
31184 arg1 = reinterpret_cast< wxWindow * >(argp1);
31185 ecode2 = SWIG_AsVal_int(obj1, &val2);
31186 if (!SWIG_IsOK(ecode2)) {
31187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31188 }
31189 arg2 = static_cast< int >(val2);
31190 ecode3 = SWIG_AsVal_int(obj2, &val3);
31191 if (!SWIG_IsOK(ecode3)) {
31192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31193 }
31194 arg3 = static_cast< int >(val3);
31195 if (obj3) {
31196 ecode4 = SWIG_AsVal_int(obj3, &val4);
31197 if (!SWIG_IsOK(ecode4)) {
31198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31199 }
31200 arg4 = static_cast< int >(val4);
31201 }
31202 if (obj4) {
31203 ecode5 = SWIG_AsVal_int(obj4, &val5);
31204 if (!SWIG_IsOK(ecode5)) {
31205 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31206 }
31207 arg5 = static_cast< int >(val5);
31208 }
31209 if (obj5) {
31210 ecode6 = SWIG_AsVal_int(obj5, &val6);
31211 if (!SWIG_IsOK(ecode6)) {
31212 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31213 }
31214 arg6 = static_cast< int >(val6);
31215 }
31216 if (obj6) {
31217 ecode7 = SWIG_AsVal_int(obj6, &val7);
31218 if (!SWIG_IsOK(ecode7)) {
31219 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31220 }
31221 arg7 = static_cast< int >(val7);
31222 }
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31226 wxPyEndAllowThreads(__tstate);
31227 if (PyErr_Occurred()) SWIG_fail;
31228 }
31229 resultobj = SWIG_Py_Void();
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31237 PyObject *resultobj = 0;
31238 wxWindow *arg1 = (wxWindow *) 0 ;
31239 wxSize *arg2 = 0 ;
31240 wxSize const &arg3_defvalue = wxDefaultSize ;
31241 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31242 wxSize const &arg4_defvalue = wxDefaultSize ;
31243 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31244 void *argp1 = 0 ;
31245 int res1 = 0 ;
31246 wxSize temp2 ;
31247 wxSize temp3 ;
31248 wxSize temp4 ;
31249 PyObject * obj0 = 0 ;
31250 PyObject * obj1 = 0 ;
31251 PyObject * obj2 = 0 ;
31252 PyObject * obj3 = 0 ;
31253 char * kwnames[] = {
31254 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31255 };
31256
31257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31259 if (!SWIG_IsOK(res1)) {
31260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31261 }
31262 arg1 = reinterpret_cast< wxWindow * >(argp1);
31263 {
31264 arg2 = &temp2;
31265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31266 }
31267 if (obj2) {
31268 {
31269 arg3 = &temp3;
31270 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31271 }
31272 }
31273 if (obj3) {
31274 {
31275 arg4 = &temp4;
31276 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31277 }
31278 }
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_Py_Void();
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj = 0;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 int arg2 ;
31296 int arg3 ;
31297 int arg4 = (int) -1 ;
31298 int arg5 = (int) -1 ;
31299 void *argp1 = 0 ;
31300 int res1 = 0 ;
31301 int val2 ;
31302 int ecode2 = 0 ;
31303 int val3 ;
31304 int ecode3 = 0 ;
31305 int val4 ;
31306 int ecode4 = 0 ;
31307 int val5 ;
31308 int ecode5 = 0 ;
31309 PyObject * obj0 = 0 ;
31310 PyObject * obj1 = 0 ;
31311 PyObject * obj2 = 0 ;
31312 PyObject * obj3 = 0 ;
31313 PyObject * obj4 = 0 ;
31314 char * kwnames[] = {
31315 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31316 };
31317
31318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31322 }
31323 arg1 = reinterpret_cast< wxWindow * >(argp1);
31324 ecode2 = SWIG_AsVal_int(obj1, &val2);
31325 if (!SWIG_IsOK(ecode2)) {
31326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31327 }
31328 arg2 = static_cast< int >(val2);
31329 ecode3 = SWIG_AsVal_int(obj2, &val3);
31330 if (!SWIG_IsOK(ecode3)) {
31331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31332 }
31333 arg3 = static_cast< int >(val3);
31334 if (obj3) {
31335 ecode4 = SWIG_AsVal_int(obj3, &val4);
31336 if (!SWIG_IsOK(ecode4)) {
31337 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31338 }
31339 arg4 = static_cast< int >(val4);
31340 }
31341 if (obj4) {
31342 ecode5 = SWIG_AsVal_int(obj4, &val5);
31343 if (!SWIG_IsOK(ecode5)) {
31344 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31345 }
31346 arg5 = static_cast< int >(val5);
31347 }
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31351 wxPyEndAllowThreads(__tstate);
31352 if (PyErr_Occurred()) SWIG_fail;
31353 }
31354 resultobj = SWIG_Py_Void();
31355 return resultobj;
31356 fail:
31357 return NULL;
31358 }
31359
31360
31361 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj = 0;
31363 wxWindow *arg1 = (wxWindow *) 0 ;
31364 wxSize *arg2 = 0 ;
31365 wxSize const &arg3_defvalue = wxDefaultSize ;
31366 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31367 void *argp1 = 0 ;
31368 int res1 = 0 ;
31369 wxSize temp2 ;
31370 wxSize temp3 ;
31371 PyObject * obj0 = 0 ;
31372 PyObject * obj1 = 0 ;
31373 PyObject * obj2 = 0 ;
31374 char * kwnames[] = {
31375 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31376 };
31377
31378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31380 if (!SWIG_IsOK(res1)) {
31381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31382 }
31383 arg1 = reinterpret_cast< wxWindow * >(argp1);
31384 {
31385 arg2 = &temp2;
31386 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31387 }
31388 if (obj2) {
31389 {
31390 arg3 = &temp3;
31391 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31392 }
31393 }
31394 {
31395 PyThreadState* __tstate = wxPyBeginAllowThreads();
31396 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31397 wxPyEndAllowThreads(__tstate);
31398 if (PyErr_Occurred()) SWIG_fail;
31399 }
31400 resultobj = SWIG_Py_Void();
31401 return resultobj;
31402 fail:
31403 return NULL;
31404 }
31405
31406
31407 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31408 PyObject *resultobj = 0;
31409 wxWindow *arg1 = (wxWindow *) 0 ;
31410 wxSize result;
31411 void *argp1 = 0 ;
31412 int res1 = 0 ;
31413 PyObject *swig_obj[1] ;
31414
31415 if (!args) SWIG_fail;
31416 swig_obj[0] = args;
31417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31418 if (!SWIG_IsOK(res1)) {
31419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31420 }
31421 arg1 = reinterpret_cast< wxWindow * >(argp1);
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = ((wxWindow const *)arg1)->GetMaxSize();
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *resultobj = 0;
31437 wxWindow *arg1 = (wxWindow *) 0 ;
31438 wxSize result;
31439 void *argp1 = 0 ;
31440 int res1 = 0 ;
31441 PyObject *swig_obj[1] ;
31442
31443 if (!args) SWIG_fail;
31444 swig_obj[0] = args;
31445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31446 if (!SWIG_IsOK(res1)) {
31447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31448 }
31449 arg1 = reinterpret_cast< wxWindow * >(argp1);
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = ((wxWindow const *)arg1)->GetMinSize();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31464 PyObject *resultobj = 0;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 wxSize *arg2 = 0 ;
31467 void *argp1 = 0 ;
31468 int res1 = 0 ;
31469 wxSize temp2 ;
31470 PyObject * obj0 = 0 ;
31471 PyObject * obj1 = 0 ;
31472 char * kwnames[] = {
31473 (char *) "self",(char *) "minSize", NULL
31474 };
31475
31476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31478 if (!SWIG_IsOK(res1)) {
31479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31480 }
31481 arg1 = reinterpret_cast< wxWindow * >(argp1);
31482 {
31483 arg2 = &temp2;
31484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31485 }
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 (arg1)->SetMinSize((wxSize const &)*arg2);
31489 wxPyEndAllowThreads(__tstate);
31490 if (PyErr_Occurred()) SWIG_fail;
31491 }
31492 resultobj = SWIG_Py_Void();
31493 return resultobj;
31494 fail:
31495 return NULL;
31496 }
31497
31498
31499 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31500 PyObject *resultobj = 0;
31501 wxWindow *arg1 = (wxWindow *) 0 ;
31502 wxSize *arg2 = 0 ;
31503 void *argp1 = 0 ;
31504 int res1 = 0 ;
31505 wxSize temp2 ;
31506 PyObject * obj0 = 0 ;
31507 PyObject * obj1 = 0 ;
31508 char * kwnames[] = {
31509 (char *) "self",(char *) "maxSize", NULL
31510 };
31511
31512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31514 if (!SWIG_IsOK(res1)) {
31515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31516 }
31517 arg1 = reinterpret_cast< wxWindow * >(argp1);
31518 {
31519 arg2 = &temp2;
31520 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31521 }
31522 {
31523 PyThreadState* __tstate = wxPyBeginAllowThreads();
31524 (arg1)->SetMaxSize((wxSize const &)*arg2);
31525 wxPyEndAllowThreads(__tstate);
31526 if (PyErr_Occurred()) SWIG_fail;
31527 }
31528 resultobj = SWIG_Py_Void();
31529 return resultobj;
31530 fail:
31531 return NULL;
31532 }
31533
31534
31535 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31536 PyObject *resultobj = 0;
31537 wxWindow *arg1 = (wxWindow *) 0 ;
31538 int result;
31539 void *argp1 = 0 ;
31540 int res1 = 0 ;
31541 PyObject *swig_obj[1] ;
31542
31543 if (!args) SWIG_fail;
31544 swig_obj[0] = args;
31545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31546 if (!SWIG_IsOK(res1)) {
31547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31548 }
31549 arg1 = reinterpret_cast< wxWindow * >(argp1);
31550 {
31551 PyThreadState* __tstate = wxPyBeginAllowThreads();
31552 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31553 wxPyEndAllowThreads(__tstate);
31554 if (PyErr_Occurred()) SWIG_fail;
31555 }
31556 resultobj = SWIG_From_int(static_cast< int >(result));
31557 return resultobj;
31558 fail:
31559 return NULL;
31560 }
31561
31562
31563 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31564 PyObject *resultobj = 0;
31565 wxWindow *arg1 = (wxWindow *) 0 ;
31566 int result;
31567 void *argp1 = 0 ;
31568 int res1 = 0 ;
31569 PyObject *swig_obj[1] ;
31570
31571 if (!args) SWIG_fail;
31572 swig_obj[0] = args;
31573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31574 if (!SWIG_IsOK(res1)) {
31575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31576 }
31577 arg1 = reinterpret_cast< wxWindow * >(argp1);
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_From_int(static_cast< int >(result));
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31592 PyObject *resultobj = 0;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 int result;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 PyObject *swig_obj[1] ;
31598
31599 if (!args) SWIG_fail;
31600 swig_obj[0] = args;
31601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31602 if (!SWIG_IsOK(res1)) {
31603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31604 }
31605 arg1 = reinterpret_cast< wxWindow * >(argp1);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 resultobj = SWIG_From_int(static_cast< int >(result));
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31620 PyObject *resultobj = 0;
31621 wxWindow *arg1 = (wxWindow *) 0 ;
31622 int result;
31623 void *argp1 = 0 ;
31624 int res1 = 0 ;
31625 PyObject *swig_obj[1] ;
31626
31627 if (!args) SWIG_fail;
31628 swig_obj[0] = args;
31629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31630 if (!SWIG_IsOK(res1)) {
31631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31632 }
31633 arg1 = reinterpret_cast< wxWindow * >(argp1);
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31637 wxPyEndAllowThreads(__tstate);
31638 if (PyErr_Occurred()) SWIG_fail;
31639 }
31640 resultobj = SWIG_From_int(static_cast< int >(result));
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31648 PyObject *resultobj = 0;
31649 wxWindow *arg1 = (wxWindow *) 0 ;
31650 wxSize *arg2 = 0 ;
31651 void *argp1 = 0 ;
31652 int res1 = 0 ;
31653 wxSize temp2 ;
31654 PyObject * obj0 = 0 ;
31655 PyObject * obj1 = 0 ;
31656 char * kwnames[] = {
31657 (char *) "self",(char *) "size", NULL
31658 };
31659
31660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31662 if (!SWIG_IsOK(res1)) {
31663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31664 }
31665 arg1 = reinterpret_cast< wxWindow * >(argp1);
31666 {
31667 arg2 = &temp2;
31668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31669 }
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31673 wxPyEndAllowThreads(__tstate);
31674 if (PyErr_Occurred()) SWIG_fail;
31675 }
31676 resultobj = SWIG_Py_Void();
31677 return resultobj;
31678 fail:
31679 return NULL;
31680 }
31681
31682
31683 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31684 PyObject *resultobj = 0;
31685 wxWindow *arg1 = (wxWindow *) 0 ;
31686 int arg2 ;
31687 int arg3 ;
31688 void *argp1 = 0 ;
31689 int res1 = 0 ;
31690 int val2 ;
31691 int ecode2 = 0 ;
31692 int val3 ;
31693 int ecode3 = 0 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 PyObject * obj2 = 0 ;
31697 char * kwnames[] = {
31698 (char *) "self",(char *) "w",(char *) "h", NULL
31699 };
31700
31701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31705 }
31706 arg1 = reinterpret_cast< wxWindow * >(argp1);
31707 ecode2 = SWIG_AsVal_int(obj1, &val2);
31708 if (!SWIG_IsOK(ecode2)) {
31709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31710 }
31711 arg2 = static_cast< int >(val2);
31712 ecode3 = SWIG_AsVal_int(obj2, &val3);
31713 if (!SWIG_IsOK(ecode3)) {
31714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31715 }
31716 arg3 = static_cast< int >(val3);
31717 {
31718 PyThreadState* __tstate = wxPyBeginAllowThreads();
31719 (arg1)->SetVirtualSize(arg2,arg3);
31720 wxPyEndAllowThreads(__tstate);
31721 if (PyErr_Occurred()) SWIG_fail;
31722 }
31723 resultobj = SWIG_Py_Void();
31724 return resultobj;
31725 fail:
31726 return NULL;
31727 }
31728
31729
31730 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31731 PyObject *resultobj = 0;
31732 wxWindow *arg1 = (wxWindow *) 0 ;
31733 wxSize result;
31734 void *argp1 = 0 ;
31735 int res1 = 0 ;
31736 PyObject *swig_obj[1] ;
31737
31738 if (!args) SWIG_fail;
31739 swig_obj[0] = args;
31740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31741 if (!SWIG_IsOK(res1)) {
31742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31743 }
31744 arg1 = reinterpret_cast< wxWindow * >(argp1);
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 result = ((wxWindow const *)arg1)->GetVirtualSize();
31748 wxPyEndAllowThreads(__tstate);
31749 if (PyErr_Occurred()) SWIG_fail;
31750 }
31751 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31759 PyObject *resultobj = 0;
31760 wxWindow *arg1 = (wxWindow *) 0 ;
31761 int *arg2 = (int *) 0 ;
31762 int *arg3 = (int *) 0 ;
31763 void *argp1 = 0 ;
31764 int res1 = 0 ;
31765 int temp2 ;
31766 int res2 = SWIG_TMPOBJ ;
31767 int temp3 ;
31768 int res3 = SWIG_TMPOBJ ;
31769 PyObject *swig_obj[1] ;
31770
31771 arg2 = &temp2;
31772 arg3 = &temp3;
31773 if (!args) SWIG_fail;
31774 swig_obj[0] = args;
31775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31776 if (!SWIG_IsOK(res1)) {
31777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31778 }
31779 arg1 = reinterpret_cast< wxWindow * >(argp1);
31780 {
31781 PyThreadState* __tstate = wxPyBeginAllowThreads();
31782 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31783 wxPyEndAllowThreads(__tstate);
31784 if (PyErr_Occurred()) SWIG_fail;
31785 }
31786 resultobj = SWIG_Py_Void();
31787 if (SWIG_IsTmpObj(res2)) {
31788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31789 } else {
31790 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31792 }
31793 if (SWIG_IsTmpObj(res3)) {
31794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31795 } else {
31796 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31798 }
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31806 PyObject *resultobj = 0;
31807 wxWindow *arg1 = (wxWindow *) 0 ;
31808 wxSize result;
31809 void *argp1 = 0 ;
31810 int res1 = 0 ;
31811 PyObject *swig_obj[1] ;
31812
31813 if (!args) SWIG_fail;
31814 swig_obj[0] = args;
31815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31816 if (!SWIG_IsOK(res1)) {
31817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31818 }
31819 arg1 = reinterpret_cast< wxWindow * >(argp1);
31820 {
31821 PyThreadState* __tstate = wxPyBeginAllowThreads();
31822 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31823 wxPyEndAllowThreads(__tstate);
31824 if (PyErr_Occurred()) SWIG_fail;
31825 }
31826 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31834 PyObject *resultobj = 0;
31835 wxWindow *arg1 = (wxWindow *) 0 ;
31836 bool arg2 = (bool) true ;
31837 bool result;
31838 void *argp1 = 0 ;
31839 int res1 = 0 ;
31840 bool val2 ;
31841 int ecode2 = 0 ;
31842 PyObject * obj0 = 0 ;
31843 PyObject * obj1 = 0 ;
31844 char * kwnames[] = {
31845 (char *) "self",(char *) "show", NULL
31846 };
31847
31848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31850 if (!SWIG_IsOK(res1)) {
31851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31852 }
31853 arg1 = reinterpret_cast< wxWindow * >(argp1);
31854 if (obj1) {
31855 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31856 if (!SWIG_IsOK(ecode2)) {
31857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31858 }
31859 arg2 = static_cast< bool >(val2);
31860 }
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 result = (bool)(arg1)->Show(arg2);
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 {
31868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31869 }
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31877 PyObject *resultobj = 0;
31878 wxWindow *arg1 = (wxWindow *) 0 ;
31879 bool result;
31880 void *argp1 = 0 ;
31881 int res1 = 0 ;
31882 PyObject *swig_obj[1] ;
31883
31884 if (!args) SWIG_fail;
31885 swig_obj[0] = args;
31886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31887 if (!SWIG_IsOK(res1)) {
31888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
31889 }
31890 arg1 = reinterpret_cast< wxWindow * >(argp1);
31891 {
31892 PyThreadState* __tstate = wxPyBeginAllowThreads();
31893 result = (bool)(arg1)->Hide();
31894 wxPyEndAllowThreads(__tstate);
31895 if (PyErr_Occurred()) SWIG_fail;
31896 }
31897 {
31898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31899 }
31900 return resultobj;
31901 fail:
31902 return NULL;
31903 }
31904
31905
31906 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31907 PyObject *resultobj = 0;
31908 wxWindow *arg1 = (wxWindow *) 0 ;
31909 bool arg2 = (bool) true ;
31910 bool result;
31911 void *argp1 = 0 ;
31912 int res1 = 0 ;
31913 bool val2 ;
31914 int ecode2 = 0 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 char * kwnames[] = {
31918 (char *) "self",(char *) "enable", NULL
31919 };
31920
31921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
31922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31923 if (!SWIG_IsOK(res1)) {
31924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
31925 }
31926 arg1 = reinterpret_cast< wxWindow * >(argp1);
31927 if (obj1) {
31928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31929 if (!SWIG_IsOK(ecode2)) {
31930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
31931 }
31932 arg2 = static_cast< bool >(val2);
31933 }
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (bool)(arg1)->Enable(arg2);
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 {
31941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31942 }
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31950 PyObject *resultobj = 0;
31951 wxWindow *arg1 = (wxWindow *) 0 ;
31952 bool result;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 PyObject *swig_obj[1] ;
31956
31957 if (!args) SWIG_fail;
31958 swig_obj[0] = args;
31959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
31962 }
31963 arg1 = reinterpret_cast< wxWindow * >(argp1);
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = (bool)(arg1)->Disable();
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 {
31971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31972 }
31973 return resultobj;
31974 fail:
31975 return NULL;
31976 }
31977
31978
31979 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 PyObject *resultobj = 0;
31981 wxWindow *arg1 = (wxWindow *) 0 ;
31982 bool result;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 PyObject *swig_obj[1] ;
31986
31987 if (!args) SWIG_fail;
31988 swig_obj[0] = args;
31989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31990 if (!SWIG_IsOK(res1)) {
31991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
31992 }
31993 arg1 = reinterpret_cast< wxWindow * >(argp1);
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (bool)((wxWindow const *)arg1)->IsShown();
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 {
32001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 bool result;
32013 void *argp1 = 0 ;
32014 int res1 = 0 ;
32015 PyObject *swig_obj[1] ;
32016
32017 if (!args) SWIG_fail;
32018 swig_obj[0] = args;
32019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32020 if (!SWIG_IsOK(res1)) {
32021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32022 }
32023 arg1 = reinterpret_cast< wxWindow * >(argp1);
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 {
32031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32032 }
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32040 PyObject *resultobj = 0;
32041 wxWindow *arg1 = (wxWindow *) 0 ;
32042 long arg2 ;
32043 void *argp1 = 0 ;
32044 int res1 = 0 ;
32045 long val2 ;
32046 int ecode2 = 0 ;
32047 PyObject * obj0 = 0 ;
32048 PyObject * obj1 = 0 ;
32049 char * kwnames[] = {
32050 (char *) "self",(char *) "style", NULL
32051 };
32052
32053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32055 if (!SWIG_IsOK(res1)) {
32056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32057 }
32058 arg1 = reinterpret_cast< wxWindow * >(argp1);
32059 ecode2 = SWIG_AsVal_long(obj1, &val2);
32060 if (!SWIG_IsOK(ecode2)) {
32061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32062 }
32063 arg2 = static_cast< long >(val2);
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 (arg1)->SetWindowStyleFlag(arg2);
32067 wxPyEndAllowThreads(__tstate);
32068 if (PyErr_Occurred()) SWIG_fail;
32069 }
32070 resultobj = SWIG_Py_Void();
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32078 PyObject *resultobj = 0;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 long result;
32081 void *argp1 = 0 ;
32082 int res1 = 0 ;
32083 PyObject *swig_obj[1] ;
32084
32085 if (!args) SWIG_fail;
32086 swig_obj[0] = args;
32087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32088 if (!SWIG_IsOK(res1)) {
32089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32090 }
32091 arg1 = reinterpret_cast< wxWindow * >(argp1);
32092 {
32093 PyThreadState* __tstate = wxPyBeginAllowThreads();
32094 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32095 wxPyEndAllowThreads(__tstate);
32096 if (PyErr_Occurred()) SWIG_fail;
32097 }
32098 resultobj = SWIG_From_long(static_cast< long >(result));
32099 return resultobj;
32100 fail:
32101 return NULL;
32102 }
32103
32104
32105 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32106 PyObject *resultobj = 0;
32107 wxWindow *arg1 = (wxWindow *) 0 ;
32108 int arg2 ;
32109 bool result;
32110 void *argp1 = 0 ;
32111 int res1 = 0 ;
32112 int val2 ;
32113 int ecode2 = 0 ;
32114 PyObject * obj0 = 0 ;
32115 PyObject * obj1 = 0 ;
32116 char * kwnames[] = {
32117 (char *) "self",(char *) "flag", NULL
32118 };
32119
32120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32122 if (!SWIG_IsOK(res1)) {
32123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32124 }
32125 arg1 = reinterpret_cast< wxWindow * >(argp1);
32126 ecode2 = SWIG_AsVal_int(obj1, &val2);
32127 if (!SWIG_IsOK(ecode2)) {
32128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32129 }
32130 arg2 = static_cast< int >(val2);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 {
32138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32139 }
32140 return resultobj;
32141 fail:
32142 return NULL;
32143 }
32144
32145
32146 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32147 PyObject *resultobj = 0;
32148 wxWindow *arg1 = (wxWindow *) 0 ;
32149 bool result;
32150 void *argp1 = 0 ;
32151 int res1 = 0 ;
32152 PyObject *swig_obj[1] ;
32153
32154 if (!args) SWIG_fail;
32155 swig_obj[0] = args;
32156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32159 }
32160 arg1 = reinterpret_cast< wxWindow * >(argp1);
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (bool)((wxWindow const *)arg1)->IsRetained();
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 {
32168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32169 }
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32177 PyObject *resultobj = 0;
32178 wxWindow *arg1 = (wxWindow *) 0 ;
32179 long arg2 ;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 long val2 ;
32183 int ecode2 = 0 ;
32184 PyObject * obj0 = 0 ;
32185 PyObject * obj1 = 0 ;
32186 char * kwnames[] = {
32187 (char *) "self",(char *) "exStyle", NULL
32188 };
32189
32190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32192 if (!SWIG_IsOK(res1)) {
32193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32194 }
32195 arg1 = reinterpret_cast< wxWindow * >(argp1);
32196 ecode2 = SWIG_AsVal_long(obj1, &val2);
32197 if (!SWIG_IsOK(ecode2)) {
32198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32199 }
32200 arg2 = static_cast< long >(val2);
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 (arg1)->SetExtraStyle(arg2);
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 resultobj = SWIG_Py_Void();
32208 return resultobj;
32209 fail:
32210 return NULL;
32211 }
32212
32213
32214 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32215 PyObject *resultobj = 0;
32216 wxWindow *arg1 = (wxWindow *) 0 ;
32217 long result;
32218 void *argp1 = 0 ;
32219 int res1 = 0 ;
32220 PyObject *swig_obj[1] ;
32221
32222 if (!args) SWIG_fail;
32223 swig_obj[0] = args;
32224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32225 if (!SWIG_IsOK(res1)) {
32226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32227 }
32228 arg1 = reinterpret_cast< wxWindow * >(argp1);
32229 {
32230 PyThreadState* __tstate = wxPyBeginAllowThreads();
32231 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32232 wxPyEndAllowThreads(__tstate);
32233 if (PyErr_Occurred()) SWIG_fail;
32234 }
32235 resultobj = SWIG_From_long(static_cast< long >(result));
32236 return resultobj;
32237 fail:
32238 return NULL;
32239 }
32240
32241
32242 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32243 PyObject *resultobj = 0;
32244 wxWindow *arg1 = (wxWindow *) 0 ;
32245 bool arg2 = (bool) true ;
32246 void *argp1 = 0 ;
32247 int res1 = 0 ;
32248 bool val2 ;
32249 int ecode2 = 0 ;
32250 PyObject * obj0 = 0 ;
32251 PyObject * obj1 = 0 ;
32252 char * kwnames[] = {
32253 (char *) "self",(char *) "modal", NULL
32254 };
32255
32256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32258 if (!SWIG_IsOK(res1)) {
32259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32260 }
32261 arg1 = reinterpret_cast< wxWindow * >(argp1);
32262 if (obj1) {
32263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32264 if (!SWIG_IsOK(ecode2)) {
32265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32266 }
32267 arg2 = static_cast< bool >(val2);
32268 }
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 (arg1)->MakeModal(arg2);
32272 wxPyEndAllowThreads(__tstate);
32273 if (PyErr_Occurred()) SWIG_fail;
32274 }
32275 resultobj = SWIG_Py_Void();
32276 return resultobj;
32277 fail:
32278 return NULL;
32279 }
32280
32281
32282 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32283 PyObject *resultobj = 0;
32284 wxWindow *arg1 = (wxWindow *) 0 ;
32285 bool arg2 ;
32286 void *argp1 = 0 ;
32287 int res1 = 0 ;
32288 bool val2 ;
32289 int ecode2 = 0 ;
32290 PyObject * obj0 = 0 ;
32291 PyObject * obj1 = 0 ;
32292 char * kwnames[] = {
32293 (char *) "self",(char *) "enableTheme", NULL
32294 };
32295
32296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32298 if (!SWIG_IsOK(res1)) {
32299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32300 }
32301 arg1 = reinterpret_cast< wxWindow * >(argp1);
32302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32303 if (!SWIG_IsOK(ecode2)) {
32304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32305 }
32306 arg2 = static_cast< bool >(val2);
32307 {
32308 PyThreadState* __tstate = wxPyBeginAllowThreads();
32309 (arg1)->SetThemeEnabled(arg2);
32310 wxPyEndAllowThreads(__tstate);
32311 if (PyErr_Occurred()) SWIG_fail;
32312 }
32313 resultobj = SWIG_Py_Void();
32314 return resultobj;
32315 fail:
32316 return NULL;
32317 }
32318
32319
32320 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32321 PyObject *resultobj = 0;
32322 wxWindow *arg1 = (wxWindow *) 0 ;
32323 bool result;
32324 void *argp1 = 0 ;
32325 int res1 = 0 ;
32326 PyObject *swig_obj[1] ;
32327
32328 if (!args) SWIG_fail;
32329 swig_obj[0] = args;
32330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32331 if (!SWIG_IsOK(res1)) {
32332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32333 }
32334 arg1 = reinterpret_cast< wxWindow * >(argp1);
32335 {
32336 PyThreadState* __tstate = wxPyBeginAllowThreads();
32337 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 {
32342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32343 }
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 PyObject *resultobj = 0;
32352 wxWindow *arg1 = (wxWindow *) 0 ;
32353 void *argp1 = 0 ;
32354 int res1 = 0 ;
32355 PyObject *swig_obj[1] ;
32356
32357 if (!args) SWIG_fail;
32358 swig_obj[0] = args;
32359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32360 if (!SWIG_IsOK(res1)) {
32361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32362 }
32363 arg1 = reinterpret_cast< wxWindow * >(argp1);
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 (arg1)->SetFocus();
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = SWIG_Py_Void();
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32378 PyObject *resultobj = 0;
32379 wxWindow *arg1 = (wxWindow *) 0 ;
32380 void *argp1 = 0 ;
32381 int res1 = 0 ;
32382 PyObject *swig_obj[1] ;
32383
32384 if (!args) SWIG_fail;
32385 swig_obj[0] = args;
32386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32387 if (!SWIG_IsOK(res1)) {
32388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32389 }
32390 arg1 = reinterpret_cast< wxWindow * >(argp1);
32391 {
32392 PyThreadState* __tstate = wxPyBeginAllowThreads();
32393 (arg1)->SetFocusFromKbd();
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 resultobj = SWIG_Py_Void();
32398 return resultobj;
32399 fail:
32400 return NULL;
32401 }
32402
32403
32404 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32405 PyObject *resultobj = 0;
32406 wxWindow *result = 0 ;
32407
32408 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32409 {
32410 if (!wxPyCheckForApp()) SWIG_fail;
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (wxWindow *)wxWindow::FindFocus();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = wxPyMake_wxObject(result, 0);
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 bool result;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 PyObject *swig_obj[1] ;
32432
32433 if (!args) SWIG_fail;
32434 swig_obj[0] = args;
32435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32438 }
32439 arg1 = reinterpret_cast< wxWindow * >(argp1);
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32448 }
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxWindow *arg1 = (wxWindow *) 0 ;
32458 bool result;
32459 void *argp1 = 0 ;
32460 int res1 = 0 ;
32461 PyObject *swig_obj[1] ;
32462
32463 if (!args) SWIG_fail;
32464 swig_obj[0] = args;
32465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32466 if (!SWIG_IsOK(res1)) {
32467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32468 }
32469 arg1 = reinterpret_cast< wxWindow * >(argp1);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 {
32477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32478 }
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32486 PyObject *resultobj = 0;
32487 wxWindow *arg1 = (wxWindow *) 0 ;
32488 wxWindow *result = 0 ;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 PyObject *swig_obj[1] ;
32492
32493 if (!args) SWIG_fail;
32494 swig_obj[0] = args;
32495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32498 }
32499 arg1 = reinterpret_cast< wxWindow * >(argp1);
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 {
32507 resultobj = wxPyMake_wxObject(result, 0);
32508 }
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32516 PyObject *resultobj = 0;
32517 wxWindow *arg1 = (wxWindow *) 0 ;
32518 wxWindow *arg2 = (wxWindow *) 0 ;
32519 wxWindow *result = 0 ;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 void *argp2 = 0 ;
32523 int res2 = 0 ;
32524 PyObject * obj0 = 0 ;
32525 PyObject * obj1 = 0 ;
32526 char * kwnames[] = {
32527 (char *) "self",(char *) "child", NULL
32528 };
32529
32530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32532 if (!SWIG_IsOK(res1)) {
32533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32534 }
32535 arg1 = reinterpret_cast< wxWindow * >(argp1);
32536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32537 if (!SWIG_IsOK(res2)) {
32538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32539 }
32540 arg2 = reinterpret_cast< wxWindow * >(argp2);
32541 {
32542 PyThreadState* __tstate = wxPyBeginAllowThreads();
32543 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 {
32548 resultobj = wxPyMake_wxObject(result, 0);
32549 }
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32557 PyObject *resultobj = 0;
32558 wxWindow *arg1 = (wxWindow *) 0 ;
32559 wxWindow *arg2 = (wxWindow *) 0 ;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 void *argp2 = 0 ;
32563 int res2 = 0 ;
32564 PyObject * obj0 = 0 ;
32565 PyObject * obj1 = 0 ;
32566 char * kwnames[] = {
32567 (char *) "self",(char *) "win", NULL
32568 };
32569
32570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32572 if (!SWIG_IsOK(res1)) {
32573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32574 }
32575 arg1 = reinterpret_cast< wxWindow * >(argp1);
32576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32577 if (!SWIG_IsOK(res2)) {
32578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32579 }
32580 arg2 = reinterpret_cast< wxWindow * >(argp2);
32581 {
32582 PyThreadState* __tstate = wxPyBeginAllowThreads();
32583 (arg1)->SetTmpDefaultItem(arg2);
32584 wxPyEndAllowThreads(__tstate);
32585 if (PyErr_Occurred()) SWIG_fail;
32586 }
32587 resultobj = SWIG_Py_Void();
32588 return resultobj;
32589 fail:
32590 return NULL;
32591 }
32592
32593
32594 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32595 PyObject *resultobj = 0;
32596 wxWindow *arg1 = (wxWindow *) 0 ;
32597 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32598 bool result;
32599 void *argp1 = 0 ;
32600 int res1 = 0 ;
32601 int val2 ;
32602 int ecode2 = 0 ;
32603 PyObject * obj0 = 0 ;
32604 PyObject * obj1 = 0 ;
32605 char * kwnames[] = {
32606 (char *) "self",(char *) "flags", NULL
32607 };
32608
32609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32611 if (!SWIG_IsOK(res1)) {
32612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32613 }
32614 arg1 = reinterpret_cast< wxWindow * >(argp1);
32615 if (obj1) {
32616 ecode2 = SWIG_AsVal_int(obj1, &val2);
32617 if (!SWIG_IsOK(ecode2)) {
32618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32619 }
32620 arg2 = static_cast< int >(val2);
32621 }
32622 {
32623 PyThreadState* __tstate = wxPyBeginAllowThreads();
32624 result = (bool)(arg1)->Navigate(arg2);
32625 wxPyEndAllowThreads(__tstate);
32626 if (PyErr_Occurred()) SWIG_fail;
32627 }
32628 {
32629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32630 }
32631 return resultobj;
32632 fail:
32633 return NULL;
32634 }
32635
32636
32637 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32638 PyObject *resultobj = 0;
32639 wxWindow *arg1 = (wxWindow *) 0 ;
32640 wxWindow *arg2 = (wxWindow *) 0 ;
32641 void *argp1 = 0 ;
32642 int res1 = 0 ;
32643 void *argp2 = 0 ;
32644 int res2 = 0 ;
32645 PyObject * obj0 = 0 ;
32646 PyObject * obj1 = 0 ;
32647 char * kwnames[] = {
32648 (char *) "self",(char *) "win", NULL
32649 };
32650
32651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32653 if (!SWIG_IsOK(res1)) {
32654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32655 }
32656 arg1 = reinterpret_cast< wxWindow * >(argp1);
32657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32658 if (!SWIG_IsOK(res2)) {
32659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32660 }
32661 arg2 = reinterpret_cast< wxWindow * >(argp2);
32662 {
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 (arg1)->MoveAfterInTabOrder(arg2);
32665 wxPyEndAllowThreads(__tstate);
32666 if (PyErr_Occurred()) SWIG_fail;
32667 }
32668 resultobj = SWIG_Py_Void();
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32676 PyObject *resultobj = 0;
32677 wxWindow *arg1 = (wxWindow *) 0 ;
32678 wxWindow *arg2 = (wxWindow *) 0 ;
32679 void *argp1 = 0 ;
32680 int res1 = 0 ;
32681 void *argp2 = 0 ;
32682 int res2 = 0 ;
32683 PyObject * obj0 = 0 ;
32684 PyObject * obj1 = 0 ;
32685 char * kwnames[] = {
32686 (char *) "self",(char *) "win", NULL
32687 };
32688
32689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32691 if (!SWIG_IsOK(res1)) {
32692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32693 }
32694 arg1 = reinterpret_cast< wxWindow * >(argp1);
32695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32696 if (!SWIG_IsOK(res2)) {
32697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32698 }
32699 arg2 = reinterpret_cast< wxWindow * >(argp2);
32700 {
32701 PyThreadState* __tstate = wxPyBeginAllowThreads();
32702 (arg1)->MoveBeforeInTabOrder(arg2);
32703 wxPyEndAllowThreads(__tstate);
32704 if (PyErr_Occurred()) SWIG_fail;
32705 }
32706 resultobj = SWIG_Py_Void();
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32714 PyObject *resultobj = 0;
32715 wxWindow *arg1 = (wxWindow *) 0 ;
32716 PyObject *result = 0 ;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 PyObject *swig_obj[1] ;
32720
32721 if (!args) SWIG_fail;
32722 swig_obj[0] = args;
32723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32724 if (!SWIG_IsOK(res1)) {
32725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32726 }
32727 arg1 = reinterpret_cast< wxWindow * >(argp1);
32728 {
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = (PyObject *)wxWindow_GetChildren(arg1);
32731 wxPyEndAllowThreads(__tstate);
32732 if (PyErr_Occurred()) SWIG_fail;
32733 }
32734 resultobj = result;
32735 return resultobj;
32736 fail:
32737 return NULL;
32738 }
32739
32740
32741 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32742 PyObject *resultobj = 0;
32743 wxWindow *arg1 = (wxWindow *) 0 ;
32744 wxWindow *result = 0 ;
32745 void *argp1 = 0 ;
32746 int res1 = 0 ;
32747 PyObject *swig_obj[1] ;
32748
32749 if (!args) SWIG_fail;
32750 swig_obj[0] = args;
32751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32754 }
32755 arg1 = reinterpret_cast< wxWindow * >(argp1);
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 {
32763 resultobj = wxPyMake_wxObject(result, 0);
32764 }
32765 return resultobj;
32766 fail:
32767 return NULL;
32768 }
32769
32770
32771 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32772 PyObject *resultobj = 0;
32773 wxWindow *arg1 = (wxWindow *) 0 ;
32774 wxWindow *result = 0 ;
32775 void *argp1 = 0 ;
32776 int res1 = 0 ;
32777 PyObject *swig_obj[1] ;
32778
32779 if (!args) SWIG_fail;
32780 swig_obj[0] = args;
32781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32782 if (!SWIG_IsOK(res1)) {
32783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32784 }
32785 arg1 = reinterpret_cast< wxWindow * >(argp1);
32786 {
32787 PyThreadState* __tstate = wxPyBeginAllowThreads();
32788 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32789 wxPyEndAllowThreads(__tstate);
32790 if (PyErr_Occurred()) SWIG_fail;
32791 }
32792 {
32793 resultobj = wxPyMake_wxObject(result, 0);
32794 }
32795 return resultobj;
32796 fail:
32797 return NULL;
32798 }
32799
32800
32801 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32802 PyObject *resultobj = 0;
32803 wxWindow *arg1 = (wxWindow *) 0 ;
32804 bool result;
32805 void *argp1 = 0 ;
32806 int res1 = 0 ;
32807 PyObject *swig_obj[1] ;
32808
32809 if (!args) SWIG_fail;
32810 swig_obj[0] = args;
32811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32812 if (!SWIG_IsOK(res1)) {
32813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32814 }
32815 arg1 = reinterpret_cast< wxWindow * >(argp1);
32816 {
32817 PyThreadState* __tstate = wxPyBeginAllowThreads();
32818 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32819 wxPyEndAllowThreads(__tstate);
32820 if (PyErr_Occurred()) SWIG_fail;
32821 }
32822 {
32823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32824 }
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32832 PyObject *resultobj = 0;
32833 wxWindow *arg1 = (wxWindow *) 0 ;
32834 wxWindow *arg2 = (wxWindow *) 0 ;
32835 bool result;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 void *argp2 = 0 ;
32839 int res2 = 0 ;
32840 PyObject * obj0 = 0 ;
32841 PyObject * obj1 = 0 ;
32842 char * kwnames[] = {
32843 (char *) "self",(char *) "newParent", NULL
32844 };
32845
32846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32848 if (!SWIG_IsOK(res1)) {
32849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32850 }
32851 arg1 = reinterpret_cast< wxWindow * >(argp1);
32852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res2)) {
32854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32855 }
32856 arg2 = reinterpret_cast< wxWindow * >(argp2);
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 result = (bool)(arg1)->Reparent(arg2);
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 {
32864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32865 }
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32873 PyObject *resultobj = 0;
32874 wxWindow *arg1 = (wxWindow *) 0 ;
32875 wxWindow *arg2 = (wxWindow *) 0 ;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 void *argp2 = 0 ;
32879 int res2 = 0 ;
32880 PyObject * obj0 = 0 ;
32881 PyObject * obj1 = 0 ;
32882 char * kwnames[] = {
32883 (char *) "self",(char *) "child", NULL
32884 };
32885
32886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
32887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32888 if (!SWIG_IsOK(res1)) {
32889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32890 }
32891 arg1 = reinterpret_cast< wxWindow * >(argp1);
32892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32893 if (!SWIG_IsOK(res2)) {
32894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32895 }
32896 arg2 = reinterpret_cast< wxWindow * >(argp2);
32897 {
32898 PyThreadState* __tstate = wxPyBeginAllowThreads();
32899 (arg1)->AddChild(arg2);
32900 wxPyEndAllowThreads(__tstate);
32901 if (PyErr_Occurred()) SWIG_fail;
32902 }
32903 resultobj = SWIG_Py_Void();
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 wxWindow *arg2 = (wxWindow *) 0 ;
32914 void *argp1 = 0 ;
32915 int res1 = 0 ;
32916 void *argp2 = 0 ;
32917 int res2 = 0 ;
32918 PyObject * obj0 = 0 ;
32919 PyObject * obj1 = 0 ;
32920 char * kwnames[] = {
32921 (char *) "self",(char *) "child", NULL
32922 };
32923
32924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
32925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32926 if (!SWIG_IsOK(res1)) {
32927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32928 }
32929 arg1 = reinterpret_cast< wxWindow * >(argp1);
32930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32931 if (!SWIG_IsOK(res2)) {
32932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32933 }
32934 arg2 = reinterpret_cast< wxWindow * >(argp2);
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 (arg1)->RemoveChild(arg2);
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 resultobj = SWIG_Py_Void();
32942 return resultobj;
32943 fail:
32944 return NULL;
32945 }
32946
32947
32948 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32949 PyObject *resultobj = 0;
32950 wxWindow *arg1 = (wxWindow *) 0 ;
32951 long arg2 ;
32952 wxWindow *result = 0 ;
32953 void *argp1 = 0 ;
32954 int res1 = 0 ;
32955 long val2 ;
32956 int ecode2 = 0 ;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 char * kwnames[] = {
32960 (char *) "self",(char *) "winid", NULL
32961 };
32962
32963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
32964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32965 if (!SWIG_IsOK(res1)) {
32966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
32967 }
32968 arg1 = reinterpret_cast< wxWindow * >(argp1);
32969 ecode2 = SWIG_AsVal_long(obj1, &val2);
32970 if (!SWIG_IsOK(ecode2)) {
32971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
32972 }
32973 arg2 = static_cast< long >(val2);
32974 {
32975 PyThreadState* __tstate = wxPyBeginAllowThreads();
32976 result = (wxWindow *)(arg1)->FindWindow(arg2);
32977 wxPyEndAllowThreads(__tstate);
32978 if (PyErr_Occurred()) SWIG_fail;
32979 }
32980 {
32981 resultobj = wxPyMake_wxObject(result, 0);
32982 }
32983 return resultobj;
32984 fail:
32985 return NULL;
32986 }
32987
32988
32989 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32990 PyObject *resultobj = 0;
32991 wxWindow *arg1 = (wxWindow *) 0 ;
32992 wxString *arg2 = 0 ;
32993 wxWindow *result = 0 ;
32994 void *argp1 = 0 ;
32995 int res1 = 0 ;
32996 bool temp2 = false ;
32997 PyObject * obj0 = 0 ;
32998 PyObject * obj1 = 0 ;
32999 char * kwnames[] = {
33000 (char *) "self",(char *) "name", NULL
33001 };
33002
33003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33007 }
33008 arg1 = reinterpret_cast< wxWindow * >(argp1);
33009 {
33010 arg2 = wxString_in_helper(obj1);
33011 if (arg2 == NULL) SWIG_fail;
33012 temp2 = true;
33013 }
33014 {
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = wxPyMake_wxObject(result, 0);
33022 }
33023 {
33024 if (temp2)
33025 delete arg2;
33026 }
33027 return resultobj;
33028 fail:
33029 {
33030 if (temp2)
33031 delete arg2;
33032 }
33033 return NULL;
33034 }
33035
33036
33037 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33038 PyObject *resultobj = 0;
33039 wxWindow *arg1 = (wxWindow *) 0 ;
33040 wxEvtHandler *result = 0 ;
33041 void *argp1 = 0 ;
33042 int res1 = 0 ;
33043 PyObject *swig_obj[1] ;
33044
33045 if (!args) SWIG_fail;
33046 swig_obj[0] = args;
33047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33048 if (!SWIG_IsOK(res1)) {
33049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33050 }
33051 arg1 = reinterpret_cast< wxWindow * >(argp1);
33052 {
33053 PyThreadState* __tstate = wxPyBeginAllowThreads();
33054 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33055 wxPyEndAllowThreads(__tstate);
33056 if (PyErr_Occurred()) SWIG_fail;
33057 }
33058 {
33059 resultobj = wxPyMake_wxObject(result, 0);
33060 }
33061 return resultobj;
33062 fail:
33063 return NULL;
33064 }
33065
33066
33067 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj = 0;
33069 wxWindow *arg1 = (wxWindow *) 0 ;
33070 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 void *argp2 = 0 ;
33074 int res2 = 0 ;
33075 PyObject * obj0 = 0 ;
33076 PyObject * obj1 = 0 ;
33077 char * kwnames[] = {
33078 (char *) "self",(char *) "handler", NULL
33079 };
33080
33081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33083 if (!SWIG_IsOK(res1)) {
33084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33085 }
33086 arg1 = reinterpret_cast< wxWindow * >(argp1);
33087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33088 if (!SWIG_IsOK(res2)) {
33089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33090 }
33091 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 (arg1)->SetEventHandler(arg2);
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 resultobj = SWIG_Py_Void();
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = 0;
33107 wxWindow *arg1 = (wxWindow *) 0 ;
33108 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33109 void *argp1 = 0 ;
33110 int res1 = 0 ;
33111 void *argp2 = 0 ;
33112 int res2 = 0 ;
33113 PyObject * obj0 = 0 ;
33114 PyObject * obj1 = 0 ;
33115 char * kwnames[] = {
33116 (char *) "self",(char *) "handler", NULL
33117 };
33118
33119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33123 }
33124 arg1 = reinterpret_cast< wxWindow * >(argp1);
33125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33126 if (!SWIG_IsOK(res2)) {
33127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33128 }
33129 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 (arg1)->PushEventHandler(arg2);
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 resultobj = SWIG_Py_Void();
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33144 PyObject *resultobj = 0;
33145 wxWindow *arg1 = (wxWindow *) 0 ;
33146 bool arg2 = (bool) false ;
33147 wxEvtHandler *result = 0 ;
33148 void *argp1 = 0 ;
33149 int res1 = 0 ;
33150 bool val2 ;
33151 int ecode2 = 0 ;
33152 PyObject * obj0 = 0 ;
33153 PyObject * obj1 = 0 ;
33154 char * kwnames[] = {
33155 (char *) "self",(char *) "deleteHandler", NULL
33156 };
33157
33158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33160 if (!SWIG_IsOK(res1)) {
33161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33162 }
33163 arg1 = reinterpret_cast< wxWindow * >(argp1);
33164 if (obj1) {
33165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33166 if (!SWIG_IsOK(ecode2)) {
33167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33168 }
33169 arg2 = static_cast< bool >(val2);
33170 }
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 resultobj = wxPyMake_wxObject(result, 0);
33179 }
33180 return resultobj;
33181 fail:
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33187 PyObject *resultobj = 0;
33188 wxWindow *arg1 = (wxWindow *) 0 ;
33189 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33190 bool result;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 void *argp2 = 0 ;
33194 int res2 = 0 ;
33195 PyObject * obj0 = 0 ;
33196 PyObject * obj1 = 0 ;
33197 char * kwnames[] = {
33198 (char *) "self",(char *) "handler", NULL
33199 };
33200
33201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33203 if (!SWIG_IsOK(res1)) {
33204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33205 }
33206 arg1 = reinterpret_cast< wxWindow * >(argp1);
33207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33208 if (!SWIG_IsOK(res2)) {
33209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33210 }
33211 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (bool)(arg1)->RemoveEventHandler(arg2);
33215 wxPyEndAllowThreads(__tstate);
33216 if (PyErr_Occurred()) SWIG_fail;
33217 }
33218 {
33219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33220 }
33221 return resultobj;
33222 fail:
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 wxValidator *arg2 = 0 ;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 void *argp2 = 0 ;
33234 int res2 = 0 ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 char * kwnames[] = {
33238 (char *) "self",(char *) "validator", NULL
33239 };
33240
33241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33245 }
33246 arg1 = reinterpret_cast< wxWindow * >(argp1);
33247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33248 if (!SWIG_IsOK(res2)) {
33249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33250 }
33251 if (!argp2) {
33252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33253 }
33254 arg2 = reinterpret_cast< wxValidator * >(argp2);
33255 {
33256 PyThreadState* __tstate = wxPyBeginAllowThreads();
33257 (arg1)->SetValidator((wxValidator const &)*arg2);
33258 wxPyEndAllowThreads(__tstate);
33259 if (PyErr_Occurred()) SWIG_fail;
33260 }
33261 resultobj = SWIG_Py_Void();
33262 return resultobj;
33263 fail:
33264 return NULL;
33265 }
33266
33267
33268 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33269 PyObject *resultobj = 0;
33270 wxWindow *arg1 = (wxWindow *) 0 ;
33271 wxValidator *result = 0 ;
33272 void *argp1 = 0 ;
33273 int res1 = 0 ;
33274 PyObject *swig_obj[1] ;
33275
33276 if (!args) SWIG_fail;
33277 swig_obj[0] = args;
33278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33279 if (!SWIG_IsOK(res1)) {
33280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33281 }
33282 arg1 = reinterpret_cast< wxWindow * >(argp1);
33283 {
33284 PyThreadState* __tstate = wxPyBeginAllowThreads();
33285 result = (wxValidator *)(arg1)->GetValidator();
33286 wxPyEndAllowThreads(__tstate);
33287 if (PyErr_Occurred()) SWIG_fail;
33288 }
33289 {
33290 resultobj = wxPyMake_wxObject(result, (bool)0);
33291 }
33292 return resultobj;
33293 fail:
33294 return NULL;
33295 }
33296
33297
33298 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33299 PyObject *resultobj = 0;
33300 wxWindow *arg1 = (wxWindow *) 0 ;
33301 bool result;
33302 void *argp1 = 0 ;
33303 int res1 = 0 ;
33304 PyObject *swig_obj[1] ;
33305
33306 if (!args) SWIG_fail;
33307 swig_obj[0] = args;
33308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33309 if (!SWIG_IsOK(res1)) {
33310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33311 }
33312 arg1 = reinterpret_cast< wxWindow * >(argp1);
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 result = (bool)(arg1)->Validate();
33316 wxPyEndAllowThreads(__tstate);
33317 if (PyErr_Occurred()) SWIG_fail;
33318 }
33319 {
33320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33321 }
33322 return resultobj;
33323 fail:
33324 return NULL;
33325 }
33326
33327
33328 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33329 PyObject *resultobj = 0;
33330 wxWindow *arg1 = (wxWindow *) 0 ;
33331 bool result;
33332 void *argp1 = 0 ;
33333 int res1 = 0 ;
33334 PyObject *swig_obj[1] ;
33335
33336 if (!args) SWIG_fail;
33337 swig_obj[0] = args;
33338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33339 if (!SWIG_IsOK(res1)) {
33340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33341 }
33342 arg1 = reinterpret_cast< wxWindow * >(argp1);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (bool)(arg1)->TransferDataToWindow();
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 {
33350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33351 }
33352 return resultobj;
33353 fail:
33354 return NULL;
33355 }
33356
33357
33358 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33359 PyObject *resultobj = 0;
33360 wxWindow *arg1 = (wxWindow *) 0 ;
33361 bool result;
33362 void *argp1 = 0 ;
33363 int res1 = 0 ;
33364 PyObject *swig_obj[1] ;
33365
33366 if (!args) SWIG_fail;
33367 swig_obj[0] = args;
33368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33369 if (!SWIG_IsOK(res1)) {
33370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33371 }
33372 arg1 = reinterpret_cast< wxWindow * >(argp1);
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 result = (bool)(arg1)->TransferDataFromWindow();
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 {
33380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33381 }
33382 return resultobj;
33383 fail:
33384 return NULL;
33385 }
33386
33387
33388 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33389 PyObject *resultobj = 0;
33390 wxWindow *arg1 = (wxWindow *) 0 ;
33391 void *argp1 = 0 ;
33392 int res1 = 0 ;
33393 PyObject *swig_obj[1] ;
33394
33395 if (!args) SWIG_fail;
33396 swig_obj[0] = args;
33397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 {
33403 PyThreadState* __tstate = wxPyBeginAllowThreads();
33404 (arg1)->InitDialog();
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 resultobj = SWIG_Py_Void();
33409 return resultobj;
33410 fail:
33411 return NULL;
33412 }
33413
33414
33415 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33416 PyObject *resultobj = 0;
33417 wxWindow *arg1 = (wxWindow *) 0 ;
33418 wxAcceleratorTable *arg2 = 0 ;
33419 void *argp1 = 0 ;
33420 int res1 = 0 ;
33421 void *argp2 = 0 ;
33422 int res2 = 0 ;
33423 PyObject * obj0 = 0 ;
33424 PyObject * obj1 = 0 ;
33425 char * kwnames[] = {
33426 (char *) "self",(char *) "accel", NULL
33427 };
33428
33429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33431 if (!SWIG_IsOK(res1)) {
33432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33433 }
33434 arg1 = reinterpret_cast< wxWindow * >(argp1);
33435 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33436 if (!SWIG_IsOK(res2)) {
33437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33438 }
33439 if (!argp2) {
33440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33441 }
33442 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33446 wxPyEndAllowThreads(__tstate);
33447 if (PyErr_Occurred()) SWIG_fail;
33448 }
33449 resultobj = SWIG_Py_Void();
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33457 PyObject *resultobj = 0;
33458 wxWindow *arg1 = (wxWindow *) 0 ;
33459 wxAcceleratorTable *result = 0 ;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 PyObject *swig_obj[1] ;
33463
33464 if (!args) SWIG_fail;
33465 swig_obj[0] = args;
33466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33467 if (!SWIG_IsOK(res1)) {
33468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33469 }
33470 arg1 = reinterpret_cast< wxWindow * >(argp1);
33471 {
33472 PyThreadState* __tstate = wxPyBeginAllowThreads();
33473 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33478 return resultobj;
33479 fail:
33480 return NULL;
33481 }
33482
33483
33484 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33485 PyObject *resultobj = 0;
33486 wxWindow *arg1 = (wxWindow *) 0 ;
33487 int arg2 ;
33488 int arg3 ;
33489 int arg4 ;
33490 bool result;
33491 void *argp1 = 0 ;
33492 int res1 = 0 ;
33493 int val2 ;
33494 int ecode2 = 0 ;
33495 int val3 ;
33496 int ecode3 = 0 ;
33497 int val4 ;
33498 int ecode4 = 0 ;
33499 PyObject * obj0 = 0 ;
33500 PyObject * obj1 = 0 ;
33501 PyObject * obj2 = 0 ;
33502 PyObject * obj3 = 0 ;
33503 char * kwnames[] = {
33504 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33505 };
33506
33507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33509 if (!SWIG_IsOK(res1)) {
33510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33511 }
33512 arg1 = reinterpret_cast< wxWindow * >(argp1);
33513 ecode2 = SWIG_AsVal_int(obj1, &val2);
33514 if (!SWIG_IsOK(ecode2)) {
33515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33516 }
33517 arg2 = static_cast< int >(val2);
33518 ecode3 = SWIG_AsVal_int(obj2, &val3);
33519 if (!SWIG_IsOK(ecode3)) {
33520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33521 }
33522 arg3 = static_cast< int >(val3);
33523 ecode4 = SWIG_AsVal_int(obj3, &val4);
33524 if (!SWIG_IsOK(ecode4)) {
33525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33526 }
33527 arg4 = static_cast< int >(val4);
33528 {
33529 PyThreadState* __tstate = wxPyBeginAllowThreads();
33530 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33531 wxPyEndAllowThreads(__tstate);
33532 if (PyErr_Occurred()) SWIG_fail;
33533 }
33534 {
33535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33536 }
33537 return resultobj;
33538 fail:
33539 return NULL;
33540 }
33541
33542
33543 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33544 PyObject *resultobj = 0;
33545 wxWindow *arg1 = (wxWindow *) 0 ;
33546 int arg2 ;
33547 bool result;
33548 void *argp1 = 0 ;
33549 int res1 = 0 ;
33550 int val2 ;
33551 int ecode2 = 0 ;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 char * kwnames[] = {
33555 (char *) "self",(char *) "hotkeyId", NULL
33556 };
33557
33558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33560 if (!SWIG_IsOK(res1)) {
33561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33562 }
33563 arg1 = reinterpret_cast< wxWindow * >(argp1);
33564 ecode2 = SWIG_AsVal_int(obj1, &val2);
33565 if (!SWIG_IsOK(ecode2)) {
33566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33567 }
33568 arg2 = static_cast< int >(val2);
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33577 }
33578 return resultobj;
33579 fail:
33580 return NULL;
33581 }
33582
33583
33584 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33585 PyObject *resultobj = 0;
33586 wxWindow *arg1 = (wxWindow *) 0 ;
33587 wxPoint *arg2 = 0 ;
33588 wxPoint result;
33589 void *argp1 = 0 ;
33590 int res1 = 0 ;
33591 wxPoint temp2 ;
33592 PyObject * obj0 = 0 ;
33593 PyObject * obj1 = 0 ;
33594 char * kwnames[] = {
33595 (char *) "self",(char *) "pt", NULL
33596 };
33597
33598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33600 if (!SWIG_IsOK(res1)) {
33601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33602 }
33603 arg1 = reinterpret_cast< wxWindow * >(argp1);
33604 {
33605 arg2 = &temp2;
33606 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33607 }
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33615 return resultobj;
33616 fail:
33617 return NULL;
33618 }
33619
33620
33621 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33622 PyObject *resultobj = 0;
33623 wxWindow *arg1 = (wxWindow *) 0 ;
33624 wxSize *arg2 = 0 ;
33625 wxSize result;
33626 void *argp1 = 0 ;
33627 int res1 = 0 ;
33628 wxSize temp2 ;
33629 PyObject * obj0 = 0 ;
33630 PyObject * obj1 = 0 ;
33631 char * kwnames[] = {
33632 (char *) "self",(char *) "sz", NULL
33633 };
33634
33635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33637 if (!SWIG_IsOK(res1)) {
33638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33639 }
33640 arg1 = reinterpret_cast< wxWindow * >(argp1);
33641 {
33642 arg2 = &temp2;
33643 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33644 }
33645 {
33646 PyThreadState* __tstate = wxPyBeginAllowThreads();
33647 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33648 wxPyEndAllowThreads(__tstate);
33649 if (PyErr_Occurred()) SWIG_fail;
33650 }
33651 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33659 PyObject *resultobj = 0;
33660 wxWindow *arg1 = (wxWindow *) 0 ;
33661 wxPoint *arg2 = 0 ;
33662 wxPoint result;
33663 void *argp1 = 0 ;
33664 int res1 = 0 ;
33665 wxPoint temp2 ;
33666 PyObject * obj0 = 0 ;
33667 PyObject * obj1 = 0 ;
33668 char * kwnames[] = {
33669 (char *) "self",(char *) "pt", NULL
33670 };
33671
33672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33674 if (!SWIG_IsOK(res1)) {
33675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33676 }
33677 arg1 = reinterpret_cast< wxWindow * >(argp1);
33678 {
33679 arg2 = &temp2;
33680 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33681 }
33682 {
33683 PyThreadState* __tstate = wxPyBeginAllowThreads();
33684 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33689 return resultobj;
33690 fail:
33691 return NULL;
33692 }
33693
33694
33695 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33696 PyObject *resultobj = 0;
33697 wxWindow *arg1 = (wxWindow *) 0 ;
33698 wxSize *arg2 = 0 ;
33699 wxSize result;
33700 void *argp1 = 0 ;
33701 int res1 = 0 ;
33702 wxSize temp2 ;
33703 PyObject * obj0 = 0 ;
33704 PyObject * obj1 = 0 ;
33705 char * kwnames[] = {
33706 (char *) "self",(char *) "sz", NULL
33707 };
33708
33709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33711 if (!SWIG_IsOK(res1)) {
33712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33713 }
33714 arg1 = reinterpret_cast< wxWindow * >(argp1);
33715 {
33716 arg2 = &temp2;
33717 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33718 }
33719 {
33720 PyThreadState* __tstate = wxPyBeginAllowThreads();
33721 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33722 wxPyEndAllowThreads(__tstate);
33723 if (PyErr_Occurred()) SWIG_fail;
33724 }
33725 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33726 return resultobj;
33727 fail:
33728 return NULL;
33729 }
33730
33731
33732 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33733 PyObject *resultobj = 0;
33734 wxWindow *arg1 = (wxWindow *) 0 ;
33735 wxPoint *arg2 = 0 ;
33736 wxPoint result;
33737 void *argp1 = 0 ;
33738 int res1 = 0 ;
33739 wxPoint temp2 ;
33740 PyObject * obj0 = 0 ;
33741 PyObject * obj1 = 0 ;
33742 char * kwnames[] = {
33743 (char *) "self",(char *) "pt", NULL
33744 };
33745
33746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33748 if (!SWIG_IsOK(res1)) {
33749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33750 }
33751 arg1 = reinterpret_cast< wxWindow * >(argp1);
33752 {
33753 arg2 = &temp2;
33754 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33755 }
33756 {
33757 PyThreadState* __tstate = wxPyBeginAllowThreads();
33758 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33759 wxPyEndAllowThreads(__tstate);
33760 if (PyErr_Occurred()) SWIG_fail;
33761 }
33762 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33763 return resultobj;
33764 fail:
33765 return NULL;
33766 }
33767
33768
33769 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33770 PyObject *resultobj = 0;
33771 wxWindow *arg1 = (wxWindow *) 0 ;
33772 wxSize *arg2 = 0 ;
33773 wxSize result;
33774 void *argp1 = 0 ;
33775 int res1 = 0 ;
33776 wxSize temp2 ;
33777 PyObject * obj0 = 0 ;
33778 PyObject * obj1 = 0 ;
33779 char * kwnames[] = {
33780 (char *) "self",(char *) "sz", NULL
33781 };
33782
33783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33785 if (!SWIG_IsOK(res1)) {
33786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33787 }
33788 arg1 = reinterpret_cast< wxWindow * >(argp1);
33789 {
33790 arg2 = &temp2;
33791 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33792 }
33793 {
33794 PyThreadState* __tstate = wxPyBeginAllowThreads();
33795 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33796 wxPyEndAllowThreads(__tstate);
33797 if (PyErr_Occurred()) SWIG_fail;
33798 }
33799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33800 return resultobj;
33801 fail:
33802 return NULL;
33803 }
33804
33805
33806 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33807 PyObject *resultobj = 0;
33808 wxWindow *arg1 = (wxWindow *) 0 ;
33809 int arg2 ;
33810 int arg3 ;
33811 void *argp1 = 0 ;
33812 int res1 = 0 ;
33813 int val2 ;
33814 int ecode2 = 0 ;
33815 int val3 ;
33816 int ecode3 = 0 ;
33817 PyObject * obj0 = 0 ;
33818 PyObject * obj1 = 0 ;
33819 PyObject * obj2 = 0 ;
33820 char * kwnames[] = {
33821 (char *) "self",(char *) "x",(char *) "y", NULL
33822 };
33823
33824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33826 if (!SWIG_IsOK(res1)) {
33827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33828 }
33829 arg1 = reinterpret_cast< wxWindow * >(argp1);
33830 ecode2 = SWIG_AsVal_int(obj1, &val2);
33831 if (!SWIG_IsOK(ecode2)) {
33832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33833 }
33834 arg2 = static_cast< int >(val2);
33835 ecode3 = SWIG_AsVal_int(obj2, &val3);
33836 if (!SWIG_IsOK(ecode3)) {
33837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33838 }
33839 arg3 = static_cast< int >(val3);
33840 {
33841 PyThreadState* __tstate = wxPyBeginAllowThreads();
33842 (arg1)->WarpPointer(arg2,arg3);
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 resultobj = SWIG_Py_Void();
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33854 PyObject *resultobj = 0;
33855 wxWindow *arg1 = (wxWindow *) 0 ;
33856 void *argp1 = 0 ;
33857 int res1 = 0 ;
33858 PyObject *swig_obj[1] ;
33859
33860 if (!args) SWIG_fail;
33861 swig_obj[0] = args;
33862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33863 if (!SWIG_IsOK(res1)) {
33864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33865 }
33866 arg1 = reinterpret_cast< wxWindow * >(argp1);
33867 {
33868 PyThreadState* __tstate = wxPyBeginAllowThreads();
33869 (arg1)->CaptureMouse();
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 resultobj = SWIG_Py_Void();
33874 return resultobj;
33875 fail:
33876 return NULL;
33877 }
33878
33879
33880 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33881 PyObject *resultobj = 0;
33882 wxWindow *arg1 = (wxWindow *) 0 ;
33883 void *argp1 = 0 ;
33884 int res1 = 0 ;
33885 PyObject *swig_obj[1] ;
33886
33887 if (!args) SWIG_fail;
33888 swig_obj[0] = args;
33889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33890 if (!SWIG_IsOK(res1)) {
33891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33892 }
33893 arg1 = reinterpret_cast< wxWindow * >(argp1);
33894 {
33895 PyThreadState* __tstate = wxPyBeginAllowThreads();
33896 (arg1)->ReleaseMouse();
33897 wxPyEndAllowThreads(__tstate);
33898 if (PyErr_Occurred()) SWIG_fail;
33899 }
33900 resultobj = SWIG_Py_Void();
33901 return resultobj;
33902 fail:
33903 return NULL;
33904 }
33905
33906
33907 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33908 PyObject *resultobj = 0;
33909 wxWindow *result = 0 ;
33910
33911 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
33912 {
33913 if (!wxPyCheckForApp()) SWIG_fail;
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 result = (wxWindow *)wxWindow::GetCapture();
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 {
33920 resultobj = wxPyMake_wxObject(result, 0);
33921 }
33922 return resultobj;
33923 fail:
33924 return NULL;
33925 }
33926
33927
33928 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33929 PyObject *resultobj = 0;
33930 wxWindow *arg1 = (wxWindow *) 0 ;
33931 bool result;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 PyObject *swig_obj[1] ;
33935
33936 if (!args) SWIG_fail;
33937 swig_obj[0] = args;
33938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33939 if (!SWIG_IsOK(res1)) {
33940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
33941 }
33942 arg1 = reinterpret_cast< wxWindow * >(argp1);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 result = (bool)((wxWindow const *)arg1)->HasCapture();
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 {
33950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33951 }
33952 return resultobj;
33953 fail:
33954 return NULL;
33955 }
33956
33957
33958 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33959 PyObject *resultobj = 0;
33960 wxWindow *arg1 = (wxWindow *) 0 ;
33961 bool arg2 = (bool) true ;
33962 wxRect *arg3 = (wxRect *) NULL ;
33963 void *argp1 = 0 ;
33964 int res1 = 0 ;
33965 bool val2 ;
33966 int ecode2 = 0 ;
33967 void *argp3 = 0 ;
33968 int res3 = 0 ;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 PyObject * obj2 = 0 ;
33972 char * kwnames[] = {
33973 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
33974 };
33975
33976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33978 if (!SWIG_IsOK(res1)) {
33979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
33980 }
33981 arg1 = reinterpret_cast< wxWindow * >(argp1);
33982 if (obj1) {
33983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33984 if (!SWIG_IsOK(ecode2)) {
33985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
33986 }
33987 arg2 = static_cast< bool >(val2);
33988 }
33989 if (obj2) {
33990 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
33991 if (!SWIG_IsOK(res3)) {
33992 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
33993 }
33994 arg3 = reinterpret_cast< wxRect * >(argp3);
33995 }
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 (arg1)->Refresh(arg2,(wxRect const *)arg3);
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_Py_Void();
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxWindow *arg1 = (wxWindow *) 0 ;
34012 wxRect *arg2 = 0 ;
34013 bool arg3 = (bool) true ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 wxRect temp2 ;
34017 bool val3 ;
34018 int ecode3 = 0 ;
34019 PyObject * obj0 = 0 ;
34020 PyObject * obj1 = 0 ;
34021 PyObject * obj2 = 0 ;
34022 char * kwnames[] = {
34023 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34024 };
34025
34026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34028 if (!SWIG_IsOK(res1)) {
34029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34030 }
34031 arg1 = reinterpret_cast< wxWindow * >(argp1);
34032 {
34033 arg2 = &temp2;
34034 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34035 }
34036 if (obj2) {
34037 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34038 if (!SWIG_IsOK(ecode3)) {
34039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34040 }
34041 arg3 = static_cast< bool >(val3);
34042 }
34043 {
34044 PyThreadState* __tstate = wxPyBeginAllowThreads();
34045 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34046 wxPyEndAllowThreads(__tstate);
34047 if (PyErr_Occurred()) SWIG_fail;
34048 }
34049 resultobj = SWIG_Py_Void();
34050 return resultobj;
34051 fail:
34052 return NULL;
34053 }
34054
34055
34056 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34057 PyObject *resultobj = 0;
34058 wxWindow *arg1 = (wxWindow *) 0 ;
34059 void *argp1 = 0 ;
34060 int res1 = 0 ;
34061 PyObject *swig_obj[1] ;
34062
34063 if (!args) SWIG_fail;
34064 swig_obj[0] = args;
34065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34066 if (!SWIG_IsOK(res1)) {
34067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34068 }
34069 arg1 = reinterpret_cast< wxWindow * >(argp1);
34070 {
34071 PyThreadState* __tstate = wxPyBeginAllowThreads();
34072 (arg1)->Update();
34073 wxPyEndAllowThreads(__tstate);
34074 if (PyErr_Occurred()) SWIG_fail;
34075 }
34076 resultobj = SWIG_Py_Void();
34077 return resultobj;
34078 fail:
34079 return NULL;
34080 }
34081
34082
34083 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34084 PyObject *resultobj = 0;
34085 wxWindow *arg1 = (wxWindow *) 0 ;
34086 void *argp1 = 0 ;
34087 int res1 = 0 ;
34088 PyObject *swig_obj[1] ;
34089
34090 if (!args) SWIG_fail;
34091 swig_obj[0] = args;
34092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34093 if (!SWIG_IsOK(res1)) {
34094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34095 }
34096 arg1 = reinterpret_cast< wxWindow * >(argp1);
34097 {
34098 PyThreadState* __tstate = wxPyBeginAllowThreads();
34099 (arg1)->ClearBackground();
34100 wxPyEndAllowThreads(__tstate);
34101 if (PyErr_Occurred()) SWIG_fail;
34102 }
34103 resultobj = SWIG_Py_Void();
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34111 PyObject *resultobj = 0;
34112 wxWindow *arg1 = (wxWindow *) 0 ;
34113 void *argp1 = 0 ;
34114 int res1 = 0 ;
34115 PyObject *swig_obj[1] ;
34116
34117 if (!args) SWIG_fail;
34118 swig_obj[0] = args;
34119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34120 if (!SWIG_IsOK(res1)) {
34121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34122 }
34123 arg1 = reinterpret_cast< wxWindow * >(argp1);
34124 {
34125 PyThreadState* __tstate = wxPyBeginAllowThreads();
34126 (arg1)->Freeze();
34127 wxPyEndAllowThreads(__tstate);
34128 if (PyErr_Occurred()) SWIG_fail;
34129 }
34130 resultobj = SWIG_Py_Void();
34131 return resultobj;
34132 fail:
34133 return NULL;
34134 }
34135
34136
34137 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34138 PyObject *resultobj = 0;
34139 wxWindow *arg1 = (wxWindow *) 0 ;
34140 void *argp1 = 0 ;
34141 int res1 = 0 ;
34142 PyObject *swig_obj[1] ;
34143
34144 if (!args) SWIG_fail;
34145 swig_obj[0] = args;
34146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34147 if (!SWIG_IsOK(res1)) {
34148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34149 }
34150 arg1 = reinterpret_cast< wxWindow * >(argp1);
34151 {
34152 PyThreadState* __tstate = wxPyBeginAllowThreads();
34153 (arg1)->Thaw();
34154 wxPyEndAllowThreads(__tstate);
34155 if (PyErr_Occurred()) SWIG_fail;
34156 }
34157 resultobj = SWIG_Py_Void();
34158 return resultobj;
34159 fail:
34160 return NULL;
34161 }
34162
34163
34164 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34165 PyObject *resultobj = 0;
34166 wxWindow *arg1 = (wxWindow *) 0 ;
34167 wxDC *arg2 = 0 ;
34168 void *argp1 = 0 ;
34169 int res1 = 0 ;
34170 void *argp2 = 0 ;
34171 int res2 = 0 ;
34172 PyObject * obj0 = 0 ;
34173 PyObject * obj1 = 0 ;
34174 char * kwnames[] = {
34175 (char *) "self",(char *) "dc", NULL
34176 };
34177
34178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34182 }
34183 arg1 = reinterpret_cast< wxWindow * >(argp1);
34184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34185 if (!SWIG_IsOK(res2)) {
34186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34187 }
34188 if (!argp2) {
34189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34190 }
34191 arg2 = reinterpret_cast< wxDC * >(argp2);
34192 {
34193 PyThreadState* __tstate = wxPyBeginAllowThreads();
34194 (arg1)->PrepareDC(*arg2);
34195 wxPyEndAllowThreads(__tstate);
34196 if (PyErr_Occurred()) SWIG_fail;
34197 }
34198 resultobj = SWIG_Py_Void();
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34206 PyObject *resultobj = 0;
34207 wxWindow *arg1 = (wxWindow *) 0 ;
34208 wxRegion *result = 0 ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 PyObject *swig_obj[1] ;
34212
34213 if (!args) SWIG_fail;
34214 swig_obj[0] = args;
34215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34216 if (!SWIG_IsOK(res1)) {
34217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34218 }
34219 arg1 = reinterpret_cast< wxWindow * >(argp1);
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 {
34223 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34224 result = (wxRegion *) &_result_ref;
34225 }
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 wxRect result;
34240 void *argp1 = 0 ;
34241 int res1 = 0 ;
34242 PyObject *swig_obj[1] ;
34243
34244 if (!args) SWIG_fail;
34245 swig_obj[0] = args;
34246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34247 if (!SWIG_IsOK(res1)) {
34248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34249 }
34250 arg1 = reinterpret_cast< wxWindow * >(argp1);
34251 {
34252 PyThreadState* __tstate = wxPyBeginAllowThreads();
34253 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34254 wxPyEndAllowThreads(__tstate);
34255 if (PyErr_Occurred()) SWIG_fail;
34256 }
34257 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34258 return resultobj;
34259 fail:
34260 return NULL;
34261 }
34262
34263
34264 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34265 PyObject *resultobj = 0;
34266 wxWindow *arg1 = (wxWindow *) 0 ;
34267 int arg2 ;
34268 int arg3 ;
34269 int arg4 = (int) 1 ;
34270 int arg5 = (int) 1 ;
34271 bool result;
34272 void *argp1 = 0 ;
34273 int res1 = 0 ;
34274 int val2 ;
34275 int ecode2 = 0 ;
34276 int val3 ;
34277 int ecode3 = 0 ;
34278 int val4 ;
34279 int ecode4 = 0 ;
34280 int val5 ;
34281 int ecode5 = 0 ;
34282 PyObject * obj0 = 0 ;
34283 PyObject * obj1 = 0 ;
34284 PyObject * obj2 = 0 ;
34285 PyObject * obj3 = 0 ;
34286 PyObject * obj4 = 0 ;
34287 char * kwnames[] = {
34288 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34289 };
34290
34291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34293 if (!SWIG_IsOK(res1)) {
34294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34295 }
34296 arg1 = reinterpret_cast< wxWindow * >(argp1);
34297 ecode2 = SWIG_AsVal_int(obj1, &val2);
34298 if (!SWIG_IsOK(ecode2)) {
34299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34300 }
34301 arg2 = static_cast< int >(val2);
34302 ecode3 = SWIG_AsVal_int(obj2, &val3);
34303 if (!SWIG_IsOK(ecode3)) {
34304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34305 }
34306 arg3 = static_cast< int >(val3);
34307 if (obj3) {
34308 ecode4 = SWIG_AsVal_int(obj3, &val4);
34309 if (!SWIG_IsOK(ecode4)) {
34310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34311 }
34312 arg4 = static_cast< int >(val4);
34313 }
34314 if (obj4) {
34315 ecode5 = SWIG_AsVal_int(obj4, &val5);
34316 if (!SWIG_IsOK(ecode5)) {
34317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34318 }
34319 arg5 = static_cast< int >(val5);
34320 }
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 {
34328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34329 }
34330 return resultobj;
34331 fail:
34332 return NULL;
34333 }
34334
34335
34336 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34337 PyObject *resultobj = 0;
34338 wxWindow *arg1 = (wxWindow *) 0 ;
34339 wxPoint *arg2 = 0 ;
34340 bool result;
34341 void *argp1 = 0 ;
34342 int res1 = 0 ;
34343 wxPoint temp2 ;
34344 PyObject * obj0 = 0 ;
34345 PyObject * obj1 = 0 ;
34346 char * kwnames[] = {
34347 (char *) "self",(char *) "pt", NULL
34348 };
34349
34350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34354 }
34355 arg1 = reinterpret_cast< wxWindow * >(argp1);
34356 {
34357 arg2 = &temp2;
34358 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34359 }
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 {
34367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34368 }
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34376 PyObject *resultobj = 0;
34377 wxWindow *arg1 = (wxWindow *) 0 ;
34378 wxRect *arg2 = 0 ;
34379 bool result;
34380 void *argp1 = 0 ;
34381 int res1 = 0 ;
34382 wxRect temp2 ;
34383 PyObject * obj0 = 0 ;
34384 PyObject * obj1 = 0 ;
34385 char * kwnames[] = {
34386 (char *) "self",(char *) "rect", NULL
34387 };
34388
34389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34391 if (!SWIG_IsOK(res1)) {
34392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34393 }
34394 arg1 = reinterpret_cast< wxWindow * >(argp1);
34395 {
34396 arg2 = &temp2;
34397 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34398 }
34399 {
34400 PyThreadState* __tstate = wxPyBeginAllowThreads();
34401 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34402 wxPyEndAllowThreads(__tstate);
34403 if (PyErr_Occurred()) SWIG_fail;
34404 }
34405 {
34406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34407 }
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 SwigValueWrapper<wxVisualAttributes > result;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj = 0;
34444 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34445 SwigValueWrapper<wxVisualAttributes > result;
34446 int val1 ;
34447 int ecode1 = 0 ;
34448 PyObject * obj0 = 0 ;
34449 char * kwnames[] = {
34450 (char *) "variant", NULL
34451 };
34452
34453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34454 if (obj0) {
34455 ecode1 = SWIG_AsVal_int(obj0, &val1);
34456 if (!SWIG_IsOK(ecode1)) {
34457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34458 }
34459 arg1 = static_cast< wxWindowVariant >(val1);
34460 }
34461 {
34462 if (!wxPyCheckForApp()) SWIG_fail;
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = wxWindow::GetClassDefaultAttributes(arg1);
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34469 return resultobj;
34470 fail:
34471 return NULL;
34472 }
34473
34474
34475 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34476 PyObject *resultobj = 0;
34477 wxWindow *arg1 = (wxWindow *) 0 ;
34478 wxColour *arg2 = 0 ;
34479 bool result;
34480 void *argp1 = 0 ;
34481 int res1 = 0 ;
34482 wxColour temp2 ;
34483 PyObject * obj0 = 0 ;
34484 PyObject * obj1 = 0 ;
34485 char * kwnames[] = {
34486 (char *) "self",(char *) "colour", NULL
34487 };
34488
34489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34491 if (!SWIG_IsOK(res1)) {
34492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34493 }
34494 arg1 = reinterpret_cast< wxWindow * >(argp1);
34495 {
34496 arg2 = &temp2;
34497 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34498 }
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34502 wxPyEndAllowThreads(__tstate);
34503 if (PyErr_Occurred()) SWIG_fail;
34504 }
34505 {
34506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34507 }
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34515 PyObject *resultobj = 0;
34516 wxWindow *arg1 = (wxWindow *) 0 ;
34517 wxColour *arg2 = 0 ;
34518 void *argp1 = 0 ;
34519 int res1 = 0 ;
34520 wxColour temp2 ;
34521 PyObject * obj0 = 0 ;
34522 PyObject * obj1 = 0 ;
34523 char * kwnames[] = {
34524 (char *) "self",(char *) "colour", NULL
34525 };
34526
34527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34529 if (!SWIG_IsOK(res1)) {
34530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34531 }
34532 arg1 = reinterpret_cast< wxWindow * >(argp1);
34533 {
34534 arg2 = &temp2;
34535 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34536 }
34537 {
34538 PyThreadState* __tstate = wxPyBeginAllowThreads();
34539 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 resultobj = SWIG_Py_Void();
34544 return resultobj;
34545 fail:
34546 return NULL;
34547 }
34548
34549
34550 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34551 PyObject *resultobj = 0;
34552 wxWindow *arg1 = (wxWindow *) 0 ;
34553 wxColour *arg2 = 0 ;
34554 bool result;
34555 void *argp1 = 0 ;
34556 int res1 = 0 ;
34557 wxColour temp2 ;
34558 PyObject * obj0 = 0 ;
34559 PyObject * obj1 = 0 ;
34560 char * kwnames[] = {
34561 (char *) "self",(char *) "colour", NULL
34562 };
34563
34564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34566 if (!SWIG_IsOK(res1)) {
34567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34568 }
34569 arg1 = reinterpret_cast< wxWindow * >(argp1);
34570 {
34571 arg2 = &temp2;
34572 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34573 }
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 {
34581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34582 }
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 wxColour *arg2 = 0 ;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 wxColour temp2 ;
34596 PyObject * obj0 = 0 ;
34597 PyObject * obj1 = 0 ;
34598 char * kwnames[] = {
34599 (char *) "self",(char *) "colour", NULL
34600 };
34601
34602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34604 if (!SWIG_IsOK(res1)) {
34605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34606 }
34607 arg1 = reinterpret_cast< wxWindow * >(argp1);
34608 {
34609 arg2 = &temp2;
34610 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34611 }
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 resultobj = SWIG_Py_Void();
34619 return resultobj;
34620 fail:
34621 return NULL;
34622 }
34623
34624
34625 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34626 PyObject *resultobj = 0;
34627 wxWindow *arg1 = (wxWindow *) 0 ;
34628 wxColour result;
34629 void *argp1 = 0 ;
34630 int res1 = 0 ;
34631 PyObject *swig_obj[1] ;
34632
34633 if (!args) SWIG_fail;
34634 swig_obj[0] = args;
34635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34636 if (!SWIG_IsOK(res1)) {
34637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34638 }
34639 arg1 = reinterpret_cast< wxWindow * >(argp1);
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 wxColour result;
34657 void *argp1 = 0 ;
34658 int res1 = 0 ;
34659 PyObject *swig_obj[1] ;
34660
34661 if (!args) SWIG_fail;
34662 swig_obj[0] = args;
34663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34664 if (!SWIG_IsOK(res1)) {
34665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34666 }
34667 arg1 = reinterpret_cast< wxWindow * >(argp1);
34668 {
34669 PyThreadState* __tstate = wxPyBeginAllowThreads();
34670 result = ((wxWindow const *)arg1)->GetForegroundColour();
34671 wxPyEndAllowThreads(__tstate);
34672 if (PyErr_Occurred()) SWIG_fail;
34673 }
34674 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34675 return resultobj;
34676 fail:
34677 return NULL;
34678 }
34679
34680
34681 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34682 PyObject *resultobj = 0;
34683 wxWindow *arg1 = (wxWindow *) 0 ;
34684 bool result;
34685 void *argp1 = 0 ;
34686 int res1 = 0 ;
34687 PyObject *swig_obj[1] ;
34688
34689 if (!args) SWIG_fail;
34690 swig_obj[0] = args;
34691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34692 if (!SWIG_IsOK(res1)) {
34693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34694 }
34695 arg1 = reinterpret_cast< wxWindow * >(argp1);
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34704 }
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 bool result;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 PyObject *swig_obj[1] ;
34718
34719 if (!args) SWIG_fail;
34720 swig_obj[0] = args;
34721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34722 if (!SWIG_IsOK(res1)) {
34723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34724 }
34725 arg1 = reinterpret_cast< wxWindow * >(argp1);
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 {
34733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34734 }
34735 return resultobj;
34736 fail:
34737 return NULL;
34738 }
34739
34740
34741 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34742 PyObject *resultobj = 0;
34743 wxWindow *arg1 = (wxWindow *) 0 ;
34744 wxBackgroundStyle arg2 ;
34745 bool result;
34746 void *argp1 = 0 ;
34747 int res1 = 0 ;
34748 int val2 ;
34749 int ecode2 = 0 ;
34750 PyObject * obj0 = 0 ;
34751 PyObject * obj1 = 0 ;
34752 char * kwnames[] = {
34753 (char *) "self",(char *) "style", NULL
34754 };
34755
34756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34758 if (!SWIG_IsOK(res1)) {
34759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34760 }
34761 arg1 = reinterpret_cast< wxWindow * >(argp1);
34762 ecode2 = SWIG_AsVal_int(obj1, &val2);
34763 if (!SWIG_IsOK(ecode2)) {
34764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34765 }
34766 arg2 = static_cast< wxBackgroundStyle >(val2);
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 {
34774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34775 }
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34783 PyObject *resultobj = 0;
34784 wxWindow *arg1 = (wxWindow *) 0 ;
34785 wxBackgroundStyle result;
34786 void *argp1 = 0 ;
34787 int res1 = 0 ;
34788 PyObject *swig_obj[1] ;
34789
34790 if (!args) SWIG_fail;
34791 swig_obj[0] = args;
34792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 {
34798 PyThreadState* __tstate = wxPyBeginAllowThreads();
34799 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 resultobj = SWIG_From_int(static_cast< int >(result));
34804 return resultobj;
34805 fail:
34806 return NULL;
34807 }
34808
34809
34810 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34811 PyObject *resultobj = 0;
34812 wxWindow *arg1 = (wxWindow *) 0 ;
34813 bool result;
34814 void *argp1 = 0 ;
34815 int res1 = 0 ;
34816 PyObject *swig_obj[1] ;
34817
34818 if (!args) SWIG_fail;
34819 swig_obj[0] = args;
34820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34821 if (!SWIG_IsOK(res1)) {
34822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34823 }
34824 arg1 = reinterpret_cast< wxWindow * >(argp1);
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (bool)(arg1)->HasTransparentBackground();
34828 wxPyEndAllowThreads(__tstate);
34829 if (PyErr_Occurred()) SWIG_fail;
34830 }
34831 {
34832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34833 }
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34841 PyObject *resultobj = 0;
34842 wxWindow *arg1 = (wxWindow *) 0 ;
34843 wxCursor *arg2 = 0 ;
34844 bool result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 void *argp2 = 0 ;
34848 int res2 = 0 ;
34849 PyObject * obj0 = 0 ;
34850 PyObject * obj1 = 0 ;
34851 char * kwnames[] = {
34852 (char *) "self",(char *) "cursor", NULL
34853 };
34854
34855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34857 if (!SWIG_IsOK(res1)) {
34858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34859 }
34860 arg1 = reinterpret_cast< wxWindow * >(argp1);
34861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34862 if (!SWIG_IsOK(res2)) {
34863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34864 }
34865 if (!argp2) {
34866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34867 }
34868 arg2 = reinterpret_cast< wxCursor * >(argp2);
34869 {
34870 PyThreadState* __tstate = wxPyBeginAllowThreads();
34871 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34872 wxPyEndAllowThreads(__tstate);
34873 if (PyErr_Occurred()) SWIG_fail;
34874 }
34875 {
34876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34877 }
34878 return resultobj;
34879 fail:
34880 return NULL;
34881 }
34882
34883
34884 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34885 PyObject *resultobj = 0;
34886 wxWindow *arg1 = (wxWindow *) 0 ;
34887 wxCursor result;
34888 void *argp1 = 0 ;
34889 int res1 = 0 ;
34890 PyObject *swig_obj[1] ;
34891
34892 if (!args) SWIG_fail;
34893 swig_obj[0] = args;
34894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34895 if (!SWIG_IsOK(res1)) {
34896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34897 }
34898 arg1 = reinterpret_cast< wxWindow * >(argp1);
34899 {
34900 PyThreadState* __tstate = wxPyBeginAllowThreads();
34901 result = (arg1)->GetCursor();
34902 wxPyEndAllowThreads(__tstate);
34903 if (PyErr_Occurred()) SWIG_fail;
34904 }
34905 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
34906 return resultobj;
34907 fail:
34908 return NULL;
34909 }
34910
34911
34912 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34913 PyObject *resultobj = 0;
34914 wxWindow *arg1 = (wxWindow *) 0 ;
34915 wxFont *arg2 = 0 ;
34916 bool result;
34917 void *argp1 = 0 ;
34918 int res1 = 0 ;
34919 void *argp2 = 0 ;
34920 int res2 = 0 ;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 char * kwnames[] = {
34924 (char *) "self",(char *) "font", NULL
34925 };
34926
34927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
34928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34929 if (!SWIG_IsOK(res1)) {
34930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34931 }
34932 arg1 = reinterpret_cast< wxWindow * >(argp1);
34933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
34934 if (!SWIG_IsOK(res2)) {
34935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34936 }
34937 if (!argp2) {
34938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34939 }
34940 arg2 = reinterpret_cast< wxFont * >(argp2);
34941 {
34942 PyThreadState* __tstate = wxPyBeginAllowThreads();
34943 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
34944 wxPyEndAllowThreads(__tstate);
34945 if (PyErr_Occurred()) SWIG_fail;
34946 }
34947 {
34948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34949 }
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34957 PyObject *resultobj = 0;
34958 wxWindow *arg1 = (wxWindow *) 0 ;
34959 wxFont *arg2 = 0 ;
34960 void *argp1 = 0 ;
34961 int res1 = 0 ;
34962 void *argp2 = 0 ;
34963 int res2 = 0 ;
34964 PyObject * obj0 = 0 ;
34965 PyObject * obj1 = 0 ;
34966 char * kwnames[] = {
34967 (char *) "self",(char *) "font", NULL
34968 };
34969
34970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
34971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34972 if (!SWIG_IsOK(res1)) {
34973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34974 }
34975 arg1 = reinterpret_cast< wxWindow * >(argp1);
34976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
34977 if (!SWIG_IsOK(res2)) {
34978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34979 }
34980 if (!argp2) {
34981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34982 }
34983 arg2 = reinterpret_cast< wxFont * >(argp2);
34984 {
34985 PyThreadState* __tstate = wxPyBeginAllowThreads();
34986 (arg1)->SetOwnFont((wxFont const &)*arg2);
34987 wxPyEndAllowThreads(__tstate);
34988 if (PyErr_Occurred()) SWIG_fail;
34989 }
34990 resultobj = SWIG_Py_Void();
34991 return resultobj;
34992 fail:
34993 return NULL;
34994 }
34995
34996
34997 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34998 PyObject *resultobj = 0;
34999 wxWindow *arg1 = (wxWindow *) 0 ;
35000 wxFont result;
35001 void *argp1 = 0 ;
35002 int res1 = 0 ;
35003 PyObject *swig_obj[1] ;
35004
35005 if (!args) SWIG_fail;
35006 swig_obj[0] = args;
35007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35008 if (!SWIG_IsOK(res1)) {
35009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35010 }
35011 arg1 = reinterpret_cast< wxWindow * >(argp1);
35012 {
35013 PyThreadState* __tstate = wxPyBeginAllowThreads();
35014 result = (arg1)->GetFont();
35015 wxPyEndAllowThreads(__tstate);
35016 if (PyErr_Occurred()) SWIG_fail;
35017 }
35018 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35019 return resultobj;
35020 fail:
35021 return NULL;
35022 }
35023
35024
35025 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35026 PyObject *resultobj = 0;
35027 wxWindow *arg1 = (wxWindow *) 0 ;
35028 wxCaret *arg2 = (wxCaret *) 0 ;
35029 void *argp1 = 0 ;
35030 int res1 = 0 ;
35031 int res2 = 0 ;
35032 PyObject * obj0 = 0 ;
35033 PyObject * obj1 = 0 ;
35034 char * kwnames[] = {
35035 (char *) "self",(char *) "caret", NULL
35036 };
35037
35038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35040 if (!SWIG_IsOK(res1)) {
35041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35042 }
35043 arg1 = reinterpret_cast< wxWindow * >(argp1);
35044 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35045 if (!SWIG_IsOK(res2)) {
35046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35047 }
35048 {
35049 PyThreadState* __tstate = wxPyBeginAllowThreads();
35050 (arg1)->SetCaret(arg2);
35051 wxPyEndAllowThreads(__tstate);
35052 if (PyErr_Occurred()) SWIG_fail;
35053 }
35054 resultobj = SWIG_Py_Void();
35055 return resultobj;
35056 fail:
35057 return NULL;
35058 }
35059
35060
35061 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35062 PyObject *resultobj = 0;
35063 wxWindow *arg1 = (wxWindow *) 0 ;
35064 wxCaret *result = 0 ;
35065 void *argp1 = 0 ;
35066 int res1 = 0 ;
35067 PyObject *swig_obj[1] ;
35068
35069 if (!args) SWIG_fail;
35070 swig_obj[0] = args;
35071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35072 if (!SWIG_IsOK(res1)) {
35073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35074 }
35075 arg1 = reinterpret_cast< wxWindow * >(argp1);
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35090 PyObject *resultobj = 0;
35091 wxWindow *arg1 = (wxWindow *) 0 ;
35092 int result;
35093 void *argp1 = 0 ;
35094 int res1 = 0 ;
35095 PyObject *swig_obj[1] ;
35096
35097 if (!args) SWIG_fail;
35098 swig_obj[0] = args;
35099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35100 if (!SWIG_IsOK(res1)) {
35101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35102 }
35103 arg1 = reinterpret_cast< wxWindow * >(argp1);
35104 {
35105 PyThreadState* __tstate = wxPyBeginAllowThreads();
35106 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35107 wxPyEndAllowThreads(__tstate);
35108 if (PyErr_Occurred()) SWIG_fail;
35109 }
35110 resultobj = SWIG_From_int(static_cast< int >(result));
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35118 PyObject *resultobj = 0;
35119 wxWindow *arg1 = (wxWindow *) 0 ;
35120 int result;
35121 void *argp1 = 0 ;
35122 int res1 = 0 ;
35123 PyObject *swig_obj[1] ;
35124
35125 if (!args) SWIG_fail;
35126 swig_obj[0] = args;
35127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35128 if (!SWIG_IsOK(res1)) {
35129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35130 }
35131 arg1 = reinterpret_cast< wxWindow * >(argp1);
35132 {
35133 PyThreadState* __tstate = wxPyBeginAllowThreads();
35134 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35135 wxPyEndAllowThreads(__tstate);
35136 if (PyErr_Occurred()) SWIG_fail;
35137 }
35138 resultobj = SWIG_From_int(static_cast< int >(result));
35139 return resultobj;
35140 fail:
35141 return NULL;
35142 }
35143
35144
35145 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35146 PyObject *resultobj = 0;
35147 wxWindow *arg1 = (wxWindow *) 0 ;
35148 wxString *arg2 = 0 ;
35149 int *arg3 = (int *) 0 ;
35150 int *arg4 = (int *) 0 ;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 bool temp2 = false ;
35154 int temp3 ;
35155 int res3 = SWIG_TMPOBJ ;
35156 int temp4 ;
35157 int res4 = SWIG_TMPOBJ ;
35158 PyObject * obj0 = 0 ;
35159 PyObject * obj1 = 0 ;
35160 char * kwnames[] = {
35161 (char *) "self",(char *) "string", NULL
35162 };
35163
35164 arg3 = &temp3;
35165 arg4 = &temp4;
35166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35168 if (!SWIG_IsOK(res1)) {
35169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35170 }
35171 arg1 = reinterpret_cast< wxWindow * >(argp1);
35172 {
35173 arg2 = wxString_in_helper(obj1);
35174 if (arg2 == NULL) SWIG_fail;
35175 temp2 = true;
35176 }
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35180 wxPyEndAllowThreads(__tstate);
35181 if (PyErr_Occurred()) SWIG_fail;
35182 }
35183 resultobj = SWIG_Py_Void();
35184 if (SWIG_IsTmpObj(res3)) {
35185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35186 } else {
35187 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35189 }
35190 if (SWIG_IsTmpObj(res4)) {
35191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35192 } else {
35193 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35195 }
35196 {
35197 if (temp2)
35198 delete arg2;
35199 }
35200 return resultobj;
35201 fail:
35202 {
35203 if (temp2)
35204 delete arg2;
35205 }
35206 return NULL;
35207 }
35208
35209
35210 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35211 PyObject *resultobj = 0;
35212 wxWindow *arg1 = (wxWindow *) 0 ;
35213 wxString *arg2 = 0 ;
35214 int *arg3 = (int *) 0 ;
35215 int *arg4 = (int *) 0 ;
35216 int *arg5 = (int *) 0 ;
35217 int *arg6 = (int *) 0 ;
35218 wxFont *arg7 = (wxFont *) NULL ;
35219 void *argp1 = 0 ;
35220 int res1 = 0 ;
35221 bool temp2 = false ;
35222 int temp3 ;
35223 int res3 = SWIG_TMPOBJ ;
35224 int temp4 ;
35225 int res4 = SWIG_TMPOBJ ;
35226 int temp5 ;
35227 int res5 = SWIG_TMPOBJ ;
35228 int temp6 ;
35229 int res6 = SWIG_TMPOBJ ;
35230 void *argp7 = 0 ;
35231 int res7 = 0 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 PyObject * obj2 = 0 ;
35235 char * kwnames[] = {
35236 (char *) "self",(char *) "string",(char *) "font", NULL
35237 };
35238
35239 arg3 = &temp3;
35240 arg4 = &temp4;
35241 arg5 = &temp5;
35242 arg6 = &temp6;
35243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35245 if (!SWIG_IsOK(res1)) {
35246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35247 }
35248 arg1 = reinterpret_cast< wxWindow * >(argp1);
35249 {
35250 arg2 = wxString_in_helper(obj1);
35251 if (arg2 == NULL) SWIG_fail;
35252 temp2 = true;
35253 }
35254 if (obj2) {
35255 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35256 if (!SWIG_IsOK(res7)) {
35257 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35258 }
35259 arg7 = reinterpret_cast< wxFont * >(argp7);
35260 }
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35264 wxPyEndAllowThreads(__tstate);
35265 if (PyErr_Occurred()) SWIG_fail;
35266 }
35267 resultobj = SWIG_Py_Void();
35268 if (SWIG_IsTmpObj(res3)) {
35269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35270 } else {
35271 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35273 }
35274 if (SWIG_IsTmpObj(res4)) {
35275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35276 } else {
35277 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35279 }
35280 if (SWIG_IsTmpObj(res5)) {
35281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35282 } else {
35283 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35285 }
35286 if (SWIG_IsTmpObj(res6)) {
35287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35288 } else {
35289 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35291 }
35292 {
35293 if (temp2)
35294 delete arg2;
35295 }
35296 return resultobj;
35297 fail:
35298 {
35299 if (temp2)
35300 delete arg2;
35301 }
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35307 PyObject *resultobj = 0;
35308 wxWindow *arg1 = (wxWindow *) 0 ;
35309 int *arg2 = (int *) 0 ;
35310 int *arg3 = (int *) 0 ;
35311 void *argp1 = 0 ;
35312 int res1 = 0 ;
35313 int temp2 ;
35314 int res2 = 0 ;
35315 int temp3 ;
35316 int res3 = 0 ;
35317 PyObject * obj0 = 0 ;
35318 PyObject * obj1 = 0 ;
35319 PyObject * obj2 = 0 ;
35320 char * kwnames[] = {
35321 (char *) "self",(char *) "x",(char *) "y", NULL
35322 };
35323
35324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35326 if (!SWIG_IsOK(res1)) {
35327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35328 }
35329 arg1 = reinterpret_cast< wxWindow * >(argp1);
35330 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35331 int val;
35332 int ecode = SWIG_AsVal_int(obj1, &val);
35333 if (!SWIG_IsOK(ecode)) {
35334 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35335 }
35336 temp2 = static_cast< int >(val);
35337 arg2 = &temp2;
35338 res2 = SWIG_AddTmpMask(ecode);
35339 }
35340 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35341 int val;
35342 int ecode = SWIG_AsVal_int(obj2, &val);
35343 if (!SWIG_IsOK(ecode)) {
35344 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35345 }
35346 temp3 = static_cast< int >(val);
35347 arg3 = &temp3;
35348 res3 = SWIG_AddTmpMask(ecode);
35349 }
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 resultobj = SWIG_Py_Void();
35357 if (SWIG_IsTmpObj(res2)) {
35358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35359 } else {
35360 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35362 }
35363 if (SWIG_IsTmpObj(res3)) {
35364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35365 } else {
35366 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35368 }
35369 return resultobj;
35370 fail:
35371 return NULL;
35372 }
35373
35374
35375 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35376 PyObject *resultobj = 0;
35377 wxWindow *arg1 = (wxWindow *) 0 ;
35378 int *arg2 = (int *) 0 ;
35379 int *arg3 = (int *) 0 ;
35380 void *argp1 = 0 ;
35381 int res1 = 0 ;
35382 int temp2 ;
35383 int res2 = 0 ;
35384 int temp3 ;
35385 int res3 = 0 ;
35386 PyObject * obj0 = 0 ;
35387 PyObject * obj1 = 0 ;
35388 PyObject * obj2 = 0 ;
35389 char * kwnames[] = {
35390 (char *) "self",(char *) "x",(char *) "y", NULL
35391 };
35392
35393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35395 if (!SWIG_IsOK(res1)) {
35396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35397 }
35398 arg1 = reinterpret_cast< wxWindow * >(argp1);
35399 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35400 int val;
35401 int ecode = SWIG_AsVal_int(obj1, &val);
35402 if (!SWIG_IsOK(ecode)) {
35403 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35404 }
35405 temp2 = static_cast< int >(val);
35406 arg2 = &temp2;
35407 res2 = SWIG_AddTmpMask(ecode);
35408 }
35409 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35410 int val;
35411 int ecode = SWIG_AsVal_int(obj2, &val);
35412 if (!SWIG_IsOK(ecode)) {
35413 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35414 }
35415 temp3 = static_cast< int >(val);
35416 arg3 = &temp3;
35417 res3 = SWIG_AddTmpMask(ecode);
35418 }
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35422 wxPyEndAllowThreads(__tstate);
35423 if (PyErr_Occurred()) SWIG_fail;
35424 }
35425 resultobj = SWIG_Py_Void();
35426 if (SWIG_IsTmpObj(res2)) {
35427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35428 } else {
35429 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35431 }
35432 if (SWIG_IsTmpObj(res3)) {
35433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35434 } else {
35435 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35437 }
35438 return resultobj;
35439 fail:
35440 return NULL;
35441 }
35442
35443
35444 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35445 PyObject *resultobj = 0;
35446 wxWindow *arg1 = (wxWindow *) 0 ;
35447 wxPoint *arg2 = 0 ;
35448 wxPoint result;
35449 void *argp1 = 0 ;
35450 int res1 = 0 ;
35451 wxPoint temp2 ;
35452 PyObject * obj0 = 0 ;
35453 PyObject * obj1 = 0 ;
35454 char * kwnames[] = {
35455 (char *) "self",(char *) "pt", NULL
35456 };
35457
35458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35460 if (!SWIG_IsOK(res1)) {
35461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35462 }
35463 arg1 = reinterpret_cast< wxWindow * >(argp1);
35464 {
35465 arg2 = &temp2;
35466 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35467 }
35468 {
35469 PyThreadState* __tstate = wxPyBeginAllowThreads();
35470 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35475 return resultobj;
35476 fail:
35477 return NULL;
35478 }
35479
35480
35481 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35482 PyObject *resultobj = 0;
35483 wxWindow *arg1 = (wxWindow *) 0 ;
35484 wxPoint *arg2 = 0 ;
35485 wxPoint result;
35486 void *argp1 = 0 ;
35487 int res1 = 0 ;
35488 wxPoint temp2 ;
35489 PyObject * obj0 = 0 ;
35490 PyObject * obj1 = 0 ;
35491 char * kwnames[] = {
35492 (char *) "self",(char *) "pt", NULL
35493 };
35494
35495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35497 if (!SWIG_IsOK(res1)) {
35498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35499 }
35500 arg1 = reinterpret_cast< wxWindow * >(argp1);
35501 {
35502 arg2 = &temp2;
35503 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35504 }
35505 {
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35512 return resultobj;
35513 fail:
35514 return NULL;
35515 }
35516
35517
35518 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35519 PyObject *resultobj = 0;
35520 wxWindow *arg1 = (wxWindow *) 0 ;
35521 int arg2 ;
35522 int arg3 ;
35523 wxHitTest result;
35524 void *argp1 = 0 ;
35525 int res1 = 0 ;
35526 int val2 ;
35527 int ecode2 = 0 ;
35528 int val3 ;
35529 int ecode3 = 0 ;
35530 PyObject * obj0 = 0 ;
35531 PyObject * obj1 = 0 ;
35532 PyObject * obj2 = 0 ;
35533 char * kwnames[] = {
35534 (char *) "self",(char *) "x",(char *) "y", NULL
35535 };
35536
35537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35539 if (!SWIG_IsOK(res1)) {
35540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35541 }
35542 arg1 = reinterpret_cast< wxWindow * >(argp1);
35543 ecode2 = SWIG_AsVal_int(obj1, &val2);
35544 if (!SWIG_IsOK(ecode2)) {
35545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35546 }
35547 arg2 = static_cast< int >(val2);
35548 ecode3 = SWIG_AsVal_int(obj2, &val3);
35549 if (!SWIG_IsOK(ecode3)) {
35550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35551 }
35552 arg3 = static_cast< int >(val3);
35553 {
35554 PyThreadState* __tstate = wxPyBeginAllowThreads();
35555 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35556 wxPyEndAllowThreads(__tstate);
35557 if (PyErr_Occurred()) SWIG_fail;
35558 }
35559 resultobj = SWIG_From_int(static_cast< int >(result));
35560 return resultobj;
35561 fail:
35562 return NULL;
35563 }
35564
35565
35566 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35567 PyObject *resultobj = 0;
35568 wxWindow *arg1 = (wxWindow *) 0 ;
35569 wxPoint *arg2 = 0 ;
35570 wxHitTest result;
35571 void *argp1 = 0 ;
35572 int res1 = 0 ;
35573 wxPoint temp2 ;
35574 PyObject * obj0 = 0 ;
35575 PyObject * obj1 = 0 ;
35576 char * kwnames[] = {
35577 (char *) "self",(char *) "pt", NULL
35578 };
35579
35580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35582 if (!SWIG_IsOK(res1)) {
35583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35584 }
35585 arg1 = reinterpret_cast< wxWindow * >(argp1);
35586 {
35587 arg2 = &temp2;
35588 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35589 }
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35593 wxPyEndAllowThreads(__tstate);
35594 if (PyErr_Occurred()) SWIG_fail;
35595 }
35596 resultobj = SWIG_From_int(static_cast< int >(result));
35597 return resultobj;
35598 fail:
35599 return NULL;
35600 }
35601
35602
35603 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35604 PyObject *resultobj = 0;
35605 wxWindow *arg1 = (wxWindow *) 0 ;
35606 long arg2 ;
35607 wxBorder result;
35608 void *argp1 = 0 ;
35609 int res1 = 0 ;
35610 long val2 ;
35611 int ecode2 = 0 ;
35612
35613 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35615 if (!SWIG_IsOK(res1)) {
35616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35617 }
35618 arg1 = reinterpret_cast< wxWindow * >(argp1);
35619 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35620 if (!SWIG_IsOK(ecode2)) {
35621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35622 }
35623 arg2 = static_cast< long >(val2);
35624 {
35625 PyThreadState* __tstate = wxPyBeginAllowThreads();
35626 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 resultobj = SWIG_From_int(static_cast< int >(result));
35631 return resultobj;
35632 fail:
35633 return NULL;
35634 }
35635
35636
35637 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35638 PyObject *resultobj = 0;
35639 wxWindow *arg1 = (wxWindow *) 0 ;
35640 wxBorder result;
35641 void *argp1 = 0 ;
35642 int res1 = 0 ;
35643
35644 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35646 if (!SWIG_IsOK(res1)) {
35647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35648 }
35649 arg1 = reinterpret_cast< wxWindow * >(argp1);
35650 {
35651 PyThreadState* __tstate = wxPyBeginAllowThreads();
35652 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35653 wxPyEndAllowThreads(__tstate);
35654 if (PyErr_Occurred()) SWIG_fail;
35655 }
35656 resultobj = SWIG_From_int(static_cast< int >(result));
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35664 int argc;
35665 PyObject *argv[3];
35666
35667 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35668 --argc;
35669 if (argc == 1) {
35670 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35671 }
35672 if (argc == 2) {
35673 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35674 }
35675
35676 fail:
35677 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35678 return NULL;
35679 }
35680
35681
35682 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35683 PyObject *resultobj = 0;
35684 wxWindow *arg1 = (wxWindow *) 0 ;
35685 long arg2 = (long) wxUPDATE_UI_NONE ;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 long val2 ;
35689 int ecode2 = 0 ;
35690 PyObject * obj0 = 0 ;
35691 PyObject * obj1 = 0 ;
35692 char * kwnames[] = {
35693 (char *) "self",(char *) "flags", NULL
35694 };
35695
35696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35698 if (!SWIG_IsOK(res1)) {
35699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35700 }
35701 arg1 = reinterpret_cast< wxWindow * >(argp1);
35702 if (obj1) {
35703 ecode2 = SWIG_AsVal_long(obj1, &val2);
35704 if (!SWIG_IsOK(ecode2)) {
35705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35706 }
35707 arg2 = static_cast< long >(val2);
35708 }
35709 {
35710 PyThreadState* __tstate = wxPyBeginAllowThreads();
35711 (arg1)->UpdateWindowUI(arg2);
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 resultobj = SWIG_Py_Void();
35716 return resultobj;
35717 fail:
35718 return NULL;
35719 }
35720
35721
35722 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35723 PyObject *resultobj = 0;
35724 wxWindow *arg1 = (wxWindow *) 0 ;
35725 wxMenu *arg2 = (wxMenu *) 0 ;
35726 int arg3 = (int) -1 ;
35727 int arg4 = (int) -1 ;
35728 bool result;
35729 void *argp1 = 0 ;
35730 int res1 = 0 ;
35731 void *argp2 = 0 ;
35732 int res2 = 0 ;
35733 int val3 ;
35734 int ecode3 = 0 ;
35735 int val4 ;
35736 int ecode4 = 0 ;
35737 PyObject * obj0 = 0 ;
35738 PyObject * obj1 = 0 ;
35739 PyObject * obj2 = 0 ;
35740 PyObject * obj3 = 0 ;
35741 char * kwnames[] = {
35742 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35743 };
35744
35745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35747 if (!SWIG_IsOK(res1)) {
35748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35749 }
35750 arg1 = reinterpret_cast< wxWindow * >(argp1);
35751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35752 if (!SWIG_IsOK(res2)) {
35753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35754 }
35755 arg2 = reinterpret_cast< wxMenu * >(argp2);
35756 if (obj2) {
35757 ecode3 = SWIG_AsVal_int(obj2, &val3);
35758 if (!SWIG_IsOK(ecode3)) {
35759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35760 }
35761 arg3 = static_cast< int >(val3);
35762 }
35763 if (obj3) {
35764 ecode4 = SWIG_AsVal_int(obj3, &val4);
35765 if (!SWIG_IsOK(ecode4)) {
35766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35767 }
35768 arg4 = static_cast< int >(val4);
35769 }
35770 {
35771 PyThreadState* __tstate = wxPyBeginAllowThreads();
35772 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35773 wxPyEndAllowThreads(__tstate);
35774 if (PyErr_Occurred()) SWIG_fail;
35775 }
35776 {
35777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35778 }
35779 return resultobj;
35780 fail:
35781 return NULL;
35782 }
35783
35784
35785 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35786 PyObject *resultobj = 0;
35787 wxWindow *arg1 = (wxWindow *) 0 ;
35788 wxMenu *arg2 = (wxMenu *) 0 ;
35789 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35790 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35791 bool result;
35792 void *argp1 = 0 ;
35793 int res1 = 0 ;
35794 void *argp2 = 0 ;
35795 int res2 = 0 ;
35796 wxPoint temp3 ;
35797 PyObject * obj0 = 0 ;
35798 PyObject * obj1 = 0 ;
35799 PyObject * obj2 = 0 ;
35800 char * kwnames[] = {
35801 (char *) "self",(char *) "menu",(char *) "pos", NULL
35802 };
35803
35804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35806 if (!SWIG_IsOK(res1)) {
35807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35808 }
35809 arg1 = reinterpret_cast< wxWindow * >(argp1);
35810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35811 if (!SWIG_IsOK(res2)) {
35812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35813 }
35814 arg2 = reinterpret_cast< wxMenu * >(argp2);
35815 if (obj2) {
35816 {
35817 arg3 = &temp3;
35818 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35819 }
35820 }
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 {
35828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35829 }
35830 return resultobj;
35831 fail:
35832 return NULL;
35833 }
35834
35835
35836 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35837 PyObject *resultobj = 0;
35838 wxWindow *arg1 = (wxWindow *) 0 ;
35839 long result;
35840 void *argp1 = 0 ;
35841 int res1 = 0 ;
35842 PyObject *swig_obj[1] ;
35843
35844 if (!args) SWIG_fail;
35845 swig_obj[0] = args;
35846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35847 if (!SWIG_IsOK(res1)) {
35848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35849 }
35850 arg1 = reinterpret_cast< wxWindow * >(argp1);
35851 {
35852 PyThreadState* __tstate = wxPyBeginAllowThreads();
35853 result = (long)wxWindow_GetHandle(arg1);
35854 wxPyEndAllowThreads(__tstate);
35855 if (PyErr_Occurred()) SWIG_fail;
35856 }
35857 resultobj = SWIG_From_long(static_cast< long >(result));
35858 return resultobj;
35859 fail:
35860 return NULL;
35861 }
35862
35863
35864 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35865 PyObject *resultobj = 0;
35866 wxWindow *arg1 = (wxWindow *) 0 ;
35867 long arg2 ;
35868 void *argp1 = 0 ;
35869 int res1 = 0 ;
35870 long val2 ;
35871 int ecode2 = 0 ;
35872 PyObject * obj0 = 0 ;
35873 PyObject * obj1 = 0 ;
35874 char * kwnames[] = {
35875 (char *) "self",(char *) "handle", NULL
35876 };
35877
35878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35880 if (!SWIG_IsOK(res1)) {
35881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35882 }
35883 arg1 = reinterpret_cast< wxWindow * >(argp1);
35884 ecode2 = SWIG_AsVal_long(obj1, &val2);
35885 if (!SWIG_IsOK(ecode2)) {
35886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
35887 }
35888 arg2 = static_cast< long >(val2);
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 wxWindow_AssociateHandle(arg1,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_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35903 PyObject *resultobj = 0;
35904 wxWindow *arg1 = (wxWindow *) 0 ;
35905 void *argp1 = 0 ;
35906 int res1 = 0 ;
35907 PyObject *swig_obj[1] ;
35908
35909 if (!args) SWIG_fail;
35910 swig_obj[0] = args;
35911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35912 if (!SWIG_IsOK(res1)) {
35913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35914 }
35915 arg1 = reinterpret_cast< wxWindow * >(argp1);
35916 {
35917 PyThreadState* __tstate = wxPyBeginAllowThreads();
35918 (arg1)->DissociateHandle();
35919 wxPyEndAllowThreads(__tstate);
35920 if (PyErr_Occurred()) SWIG_fail;
35921 }
35922 resultobj = SWIG_Py_Void();
35923 return resultobj;
35924 fail:
35925 return NULL;
35926 }
35927
35928
35929 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35930 PyObject *resultobj = 0;
35931 wxWindow *arg1 = (wxWindow *) 0 ;
35932 int arg2 ;
35933 bool result;
35934 void *argp1 = 0 ;
35935 int res1 = 0 ;
35936 int val2 ;
35937 int ecode2 = 0 ;
35938 PyObject * obj0 = 0 ;
35939 PyObject * obj1 = 0 ;
35940 char * kwnames[] = {
35941 (char *) "self",(char *) "orient", NULL
35942 };
35943
35944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
35945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35946 if (!SWIG_IsOK(res1)) {
35947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
35948 }
35949 arg1 = reinterpret_cast< wxWindow * >(argp1);
35950 ecode2 = SWIG_AsVal_int(obj1, &val2);
35951 if (!SWIG_IsOK(ecode2)) {
35952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
35953 }
35954 arg2 = static_cast< int >(val2);
35955 {
35956 PyThreadState* __tstate = wxPyBeginAllowThreads();
35957 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 {
35962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35963 }
35964 return resultobj;
35965 fail:
35966 return NULL;
35967 }
35968
35969
35970 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35971 PyObject *resultobj = 0;
35972 wxWindow *arg1 = (wxWindow *) 0 ;
35973 int arg2 ;
35974 int arg3 ;
35975 int arg4 ;
35976 int arg5 ;
35977 bool arg6 = (bool) true ;
35978 void *argp1 = 0 ;
35979 int res1 = 0 ;
35980 int val2 ;
35981 int ecode2 = 0 ;
35982 int val3 ;
35983 int ecode3 = 0 ;
35984 int val4 ;
35985 int ecode4 = 0 ;
35986 int val5 ;
35987 int ecode5 = 0 ;
35988 bool val6 ;
35989 int ecode6 = 0 ;
35990 PyObject * obj0 = 0 ;
35991 PyObject * obj1 = 0 ;
35992 PyObject * obj2 = 0 ;
35993 PyObject * obj3 = 0 ;
35994 PyObject * obj4 = 0 ;
35995 PyObject * obj5 = 0 ;
35996 char * kwnames[] = {
35997 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
35998 };
35999
36000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36002 if (!SWIG_IsOK(res1)) {
36003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36004 }
36005 arg1 = reinterpret_cast< wxWindow * >(argp1);
36006 ecode2 = SWIG_AsVal_int(obj1, &val2);
36007 if (!SWIG_IsOK(ecode2)) {
36008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36009 }
36010 arg2 = static_cast< int >(val2);
36011 ecode3 = SWIG_AsVal_int(obj2, &val3);
36012 if (!SWIG_IsOK(ecode3)) {
36013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36014 }
36015 arg3 = static_cast< int >(val3);
36016 ecode4 = SWIG_AsVal_int(obj3, &val4);
36017 if (!SWIG_IsOK(ecode4)) {
36018 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36019 }
36020 arg4 = static_cast< int >(val4);
36021 ecode5 = SWIG_AsVal_int(obj4, &val5);
36022 if (!SWIG_IsOK(ecode5)) {
36023 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36024 }
36025 arg5 = static_cast< int >(val5);
36026 if (obj5) {
36027 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36028 if (!SWIG_IsOK(ecode6)) {
36029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36030 }
36031 arg6 = static_cast< bool >(val6);
36032 }
36033 {
36034 PyThreadState* __tstate = wxPyBeginAllowThreads();
36035 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36036 wxPyEndAllowThreads(__tstate);
36037 if (PyErr_Occurred()) SWIG_fail;
36038 }
36039 resultobj = SWIG_Py_Void();
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36047 PyObject *resultobj = 0;
36048 wxWindow *arg1 = (wxWindow *) 0 ;
36049 int arg2 ;
36050 int arg3 ;
36051 bool arg4 = (bool) true ;
36052 void *argp1 = 0 ;
36053 int res1 = 0 ;
36054 int val2 ;
36055 int ecode2 = 0 ;
36056 int val3 ;
36057 int ecode3 = 0 ;
36058 bool val4 ;
36059 int ecode4 = 0 ;
36060 PyObject * obj0 = 0 ;
36061 PyObject * obj1 = 0 ;
36062 PyObject * obj2 = 0 ;
36063 PyObject * obj3 = 0 ;
36064 char * kwnames[] = {
36065 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36066 };
36067
36068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36070 if (!SWIG_IsOK(res1)) {
36071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36072 }
36073 arg1 = reinterpret_cast< wxWindow * >(argp1);
36074 ecode2 = SWIG_AsVal_int(obj1, &val2);
36075 if (!SWIG_IsOK(ecode2)) {
36076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36077 }
36078 arg2 = static_cast< int >(val2);
36079 ecode3 = SWIG_AsVal_int(obj2, &val3);
36080 if (!SWIG_IsOK(ecode3)) {
36081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36082 }
36083 arg3 = static_cast< int >(val3);
36084 if (obj3) {
36085 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36086 if (!SWIG_IsOK(ecode4)) {
36087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36088 }
36089 arg4 = static_cast< bool >(val4);
36090 }
36091 {
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 (arg1)->SetScrollPos(arg2,arg3,arg4);
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 resultobj = SWIG_Py_Void();
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj = 0;
36106 wxWindow *arg1 = (wxWindow *) 0 ;
36107 int arg2 ;
36108 int result;
36109 void *argp1 = 0 ;
36110 int res1 = 0 ;
36111 int val2 ;
36112 int ecode2 = 0 ;
36113 PyObject * obj0 = 0 ;
36114 PyObject * obj1 = 0 ;
36115 char * kwnames[] = {
36116 (char *) "self",(char *) "orientation", NULL
36117 };
36118
36119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36121 if (!SWIG_IsOK(res1)) {
36122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36123 }
36124 arg1 = reinterpret_cast< wxWindow * >(argp1);
36125 ecode2 = SWIG_AsVal_int(obj1, &val2);
36126 if (!SWIG_IsOK(ecode2)) {
36127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36128 }
36129 arg2 = static_cast< int >(val2);
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36133 wxPyEndAllowThreads(__tstate);
36134 if (PyErr_Occurred()) SWIG_fail;
36135 }
36136 resultobj = SWIG_From_int(static_cast< int >(result));
36137 return resultobj;
36138 fail:
36139 return NULL;
36140 }
36141
36142
36143 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36144 PyObject *resultobj = 0;
36145 wxWindow *arg1 = (wxWindow *) 0 ;
36146 int arg2 ;
36147 int result;
36148 void *argp1 = 0 ;
36149 int res1 = 0 ;
36150 int val2 ;
36151 int ecode2 = 0 ;
36152 PyObject * obj0 = 0 ;
36153 PyObject * obj1 = 0 ;
36154 char * kwnames[] = {
36155 (char *) "self",(char *) "orientation", NULL
36156 };
36157
36158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36160 if (!SWIG_IsOK(res1)) {
36161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36162 }
36163 arg1 = reinterpret_cast< wxWindow * >(argp1);
36164 ecode2 = SWIG_AsVal_int(obj1, &val2);
36165 if (!SWIG_IsOK(ecode2)) {
36166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36167 }
36168 arg2 = static_cast< int >(val2);
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36172 wxPyEndAllowThreads(__tstate);
36173 if (PyErr_Occurred()) SWIG_fail;
36174 }
36175 resultobj = SWIG_From_int(static_cast< int >(result));
36176 return resultobj;
36177 fail:
36178 return NULL;
36179 }
36180
36181
36182 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36183 PyObject *resultobj = 0;
36184 wxWindow *arg1 = (wxWindow *) 0 ;
36185 int arg2 ;
36186 int result;
36187 void *argp1 = 0 ;
36188 int res1 = 0 ;
36189 int val2 ;
36190 int ecode2 = 0 ;
36191 PyObject * obj0 = 0 ;
36192 PyObject * obj1 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "orientation", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_From_int(static_cast< int >(result));
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36222 PyObject *resultobj = 0;
36223 wxWindow *arg1 = (wxWindow *) 0 ;
36224 int arg2 ;
36225 int arg3 ;
36226 wxRect *arg4 = (wxRect *) NULL ;
36227 void *argp1 = 0 ;
36228 int res1 = 0 ;
36229 int val2 ;
36230 int ecode2 = 0 ;
36231 int val3 ;
36232 int ecode3 = 0 ;
36233 void *argp4 = 0 ;
36234 int res4 = 0 ;
36235 PyObject * obj0 = 0 ;
36236 PyObject * obj1 = 0 ;
36237 PyObject * obj2 = 0 ;
36238 PyObject * obj3 = 0 ;
36239 char * kwnames[] = {
36240 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36241 };
36242
36243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36245 if (!SWIG_IsOK(res1)) {
36246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36247 }
36248 arg1 = reinterpret_cast< wxWindow * >(argp1);
36249 ecode2 = SWIG_AsVal_int(obj1, &val2);
36250 if (!SWIG_IsOK(ecode2)) {
36251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36252 }
36253 arg2 = static_cast< int >(val2);
36254 ecode3 = SWIG_AsVal_int(obj2, &val3);
36255 if (!SWIG_IsOK(ecode3)) {
36256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36257 }
36258 arg3 = static_cast< int >(val3);
36259 if (obj3) {
36260 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36261 if (!SWIG_IsOK(res4)) {
36262 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36263 }
36264 arg4 = reinterpret_cast< wxRect * >(argp4);
36265 }
36266 {
36267 PyThreadState* __tstate = wxPyBeginAllowThreads();
36268 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 resultobj = SWIG_Py_Void();
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36280 PyObject *resultobj = 0;
36281 wxWindow *arg1 = (wxWindow *) 0 ;
36282 int arg2 ;
36283 bool result;
36284 void *argp1 = 0 ;
36285 int res1 = 0 ;
36286 int val2 ;
36287 int ecode2 = 0 ;
36288 PyObject * obj0 = 0 ;
36289 PyObject * obj1 = 0 ;
36290 char * kwnames[] = {
36291 (char *) "self",(char *) "lines", NULL
36292 };
36293
36294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36296 if (!SWIG_IsOK(res1)) {
36297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36298 }
36299 arg1 = reinterpret_cast< wxWindow * >(argp1);
36300 ecode2 = SWIG_AsVal_int(obj1, &val2);
36301 if (!SWIG_IsOK(ecode2)) {
36302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36303 }
36304 arg2 = static_cast< int >(val2);
36305 {
36306 PyThreadState* __tstate = wxPyBeginAllowThreads();
36307 result = (bool)(arg1)->ScrollLines(arg2);
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 {
36312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36313 }
36314 return resultobj;
36315 fail:
36316 return NULL;
36317 }
36318
36319
36320 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36321 PyObject *resultobj = 0;
36322 wxWindow *arg1 = (wxWindow *) 0 ;
36323 int arg2 ;
36324 bool result;
36325 void *argp1 = 0 ;
36326 int res1 = 0 ;
36327 int val2 ;
36328 int ecode2 = 0 ;
36329 PyObject * obj0 = 0 ;
36330 PyObject * obj1 = 0 ;
36331 char * kwnames[] = {
36332 (char *) "self",(char *) "pages", NULL
36333 };
36334
36335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36337 if (!SWIG_IsOK(res1)) {
36338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36339 }
36340 arg1 = reinterpret_cast< wxWindow * >(argp1);
36341 ecode2 = SWIG_AsVal_int(obj1, &val2);
36342 if (!SWIG_IsOK(ecode2)) {
36343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36344 }
36345 arg2 = static_cast< int >(val2);
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 result = (bool)(arg1)->ScrollPages(arg2);
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36362 PyObject *resultobj = 0;
36363 wxWindow *arg1 = (wxWindow *) 0 ;
36364 bool result;
36365 void *argp1 = 0 ;
36366 int res1 = 0 ;
36367 PyObject *swig_obj[1] ;
36368
36369 if (!args) SWIG_fail;
36370 swig_obj[0] = args;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (bool)(arg1)->LineUp();
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 {
36383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36384 }
36385 return resultobj;
36386 fail:
36387 return NULL;
36388 }
36389
36390
36391 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36392 PyObject *resultobj = 0;
36393 wxWindow *arg1 = (wxWindow *) 0 ;
36394 bool result;
36395 void *argp1 = 0 ;
36396 int res1 = 0 ;
36397 PyObject *swig_obj[1] ;
36398
36399 if (!args) SWIG_fail;
36400 swig_obj[0] = args;
36401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36402 if (!SWIG_IsOK(res1)) {
36403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36404 }
36405 arg1 = reinterpret_cast< wxWindow * >(argp1);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 result = (bool)(arg1)->LineDown();
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 {
36413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36414 }
36415 return resultobj;
36416 fail:
36417 return NULL;
36418 }
36419
36420
36421 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36422 PyObject *resultobj = 0;
36423 wxWindow *arg1 = (wxWindow *) 0 ;
36424 bool result;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 PyObject *swig_obj[1] ;
36428
36429 if (!args) SWIG_fail;
36430 swig_obj[0] = args;
36431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)(arg1)->PageUp();
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 {
36443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36444 }
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 bool result;
36455 void *argp1 = 0 ;
36456 int res1 = 0 ;
36457 PyObject *swig_obj[1] ;
36458
36459 if (!args) SWIG_fail;
36460 swig_obj[0] = args;
36461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36462 if (!SWIG_IsOK(res1)) {
36463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36464 }
36465 arg1 = reinterpret_cast< wxWindow * >(argp1);
36466 {
36467 PyThreadState* __tstate = wxPyBeginAllowThreads();
36468 result = (bool)(arg1)->PageDown();
36469 wxPyEndAllowThreads(__tstate);
36470 if (PyErr_Occurred()) SWIG_fail;
36471 }
36472 {
36473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36474 }
36475 return resultobj;
36476 fail:
36477 return NULL;
36478 }
36479
36480
36481 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36482 PyObject *resultobj = 0;
36483 wxWindow *arg1 = (wxWindow *) 0 ;
36484 wxString *arg2 = 0 ;
36485 void *argp1 = 0 ;
36486 int res1 = 0 ;
36487 bool temp2 = false ;
36488 PyObject * obj0 = 0 ;
36489 PyObject * obj1 = 0 ;
36490 char * kwnames[] = {
36491 (char *) "self",(char *) "text", NULL
36492 };
36493
36494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36496 if (!SWIG_IsOK(res1)) {
36497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36498 }
36499 arg1 = reinterpret_cast< wxWindow * >(argp1);
36500 {
36501 arg2 = wxString_in_helper(obj1);
36502 if (arg2 == NULL) SWIG_fail;
36503 temp2 = true;
36504 }
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 (arg1)->SetHelpText((wxString const &)*arg2);
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 resultobj = SWIG_Py_Void();
36512 {
36513 if (temp2)
36514 delete arg2;
36515 }
36516 return resultobj;
36517 fail:
36518 {
36519 if (temp2)
36520 delete arg2;
36521 }
36522 return NULL;
36523 }
36524
36525
36526 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36527 PyObject *resultobj = 0;
36528 wxWindow *arg1 = (wxWindow *) 0 ;
36529 wxString *arg2 = 0 ;
36530 void *argp1 = 0 ;
36531 int res1 = 0 ;
36532 bool temp2 = false ;
36533 PyObject * obj0 = 0 ;
36534 PyObject * obj1 = 0 ;
36535 char * kwnames[] = {
36536 (char *) "self",(char *) "text", NULL
36537 };
36538
36539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36541 if (!SWIG_IsOK(res1)) {
36542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36543 }
36544 arg1 = reinterpret_cast< wxWindow * >(argp1);
36545 {
36546 arg2 = wxString_in_helper(obj1);
36547 if (arg2 == NULL) SWIG_fail;
36548 temp2 = true;
36549 }
36550 {
36551 PyThreadState* __tstate = wxPyBeginAllowThreads();
36552 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36553 wxPyEndAllowThreads(__tstate);
36554 if (PyErr_Occurred()) SWIG_fail;
36555 }
36556 resultobj = SWIG_Py_Void();
36557 {
36558 if (temp2)
36559 delete arg2;
36560 }
36561 return resultobj;
36562 fail:
36563 {
36564 if (temp2)
36565 delete arg2;
36566 }
36567 return NULL;
36568 }
36569
36570
36571 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36572 PyObject *resultobj = 0;
36573 wxWindow *arg1 = (wxWindow *) 0 ;
36574 wxString result;
36575 void *argp1 = 0 ;
36576 int res1 = 0 ;
36577 PyObject *swig_obj[1] ;
36578
36579 if (!args) SWIG_fail;
36580 swig_obj[0] = args;
36581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36582 if (!SWIG_IsOK(res1)) {
36583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36584 }
36585 arg1 = reinterpret_cast< wxWindow * >(argp1);
36586 {
36587 PyThreadState* __tstate = wxPyBeginAllowThreads();
36588 result = ((wxWindow const *)arg1)->GetHelpText();
36589 wxPyEndAllowThreads(__tstate);
36590 if (PyErr_Occurred()) SWIG_fail;
36591 }
36592 {
36593 #if wxUSE_UNICODE
36594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36595 #else
36596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36597 #endif
36598 }
36599 return resultobj;
36600 fail:
36601 return NULL;
36602 }
36603
36604
36605 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36606 PyObject *resultobj = 0;
36607 wxWindow *arg1 = (wxWindow *) 0 ;
36608 wxString *arg2 = 0 ;
36609 void *argp1 = 0 ;
36610 int res1 = 0 ;
36611 bool temp2 = false ;
36612 PyObject * obj0 = 0 ;
36613 PyObject * obj1 = 0 ;
36614 char * kwnames[] = {
36615 (char *) "self",(char *) "tip", NULL
36616 };
36617
36618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36620 if (!SWIG_IsOK(res1)) {
36621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36622 }
36623 arg1 = reinterpret_cast< wxWindow * >(argp1);
36624 {
36625 arg2 = wxString_in_helper(obj1);
36626 if (arg2 == NULL) SWIG_fail;
36627 temp2 = true;
36628 }
36629 {
36630 PyThreadState* __tstate = wxPyBeginAllowThreads();
36631 (arg1)->SetToolTip((wxString const &)*arg2);
36632 wxPyEndAllowThreads(__tstate);
36633 if (PyErr_Occurred()) SWIG_fail;
36634 }
36635 resultobj = SWIG_Py_Void();
36636 {
36637 if (temp2)
36638 delete arg2;
36639 }
36640 return resultobj;
36641 fail:
36642 {
36643 if (temp2)
36644 delete arg2;
36645 }
36646 return NULL;
36647 }
36648
36649
36650 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36651 PyObject *resultobj = 0;
36652 wxWindow *arg1 = (wxWindow *) 0 ;
36653 wxToolTip *arg2 = (wxToolTip *) 0 ;
36654 void *argp1 = 0 ;
36655 int res1 = 0 ;
36656 int res2 = 0 ;
36657 PyObject * obj0 = 0 ;
36658 PyObject * obj1 = 0 ;
36659 char * kwnames[] = {
36660 (char *) "self",(char *) "tip", NULL
36661 };
36662
36663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36665 if (!SWIG_IsOK(res1)) {
36666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36667 }
36668 arg1 = reinterpret_cast< wxWindow * >(argp1);
36669 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36670 if (!SWIG_IsOK(res2)) {
36671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36672 }
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 (arg1)->SetToolTip(arg2);
36676 wxPyEndAllowThreads(__tstate);
36677 if (PyErr_Occurred()) SWIG_fail;
36678 }
36679 resultobj = SWIG_Py_Void();
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36687 PyObject *resultobj = 0;
36688 wxWindow *arg1 = (wxWindow *) 0 ;
36689 wxToolTip *result = 0 ;
36690 void *argp1 = 0 ;
36691 int res1 = 0 ;
36692 PyObject *swig_obj[1] ;
36693
36694 if (!args) SWIG_fail;
36695 swig_obj[0] = args;
36696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36697 if (!SWIG_IsOK(res1)) {
36698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36699 }
36700 arg1 = reinterpret_cast< wxWindow * >(argp1);
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36704 wxPyEndAllowThreads(__tstate);
36705 if (PyErr_Occurred()) SWIG_fail;
36706 }
36707 {
36708 resultobj = wxPyMake_wxObject(result, (bool)0);
36709 }
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36717 PyObject *resultobj = 0;
36718 wxWindow *arg1 = (wxWindow *) 0 ;
36719 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36720 void *argp1 = 0 ;
36721 int res1 = 0 ;
36722 int res2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char * kwnames[] = {
36726 (char *) "self",(char *) "dropTarget", NULL
36727 };
36728
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36736 if (!SWIG_IsOK(res2)) {
36737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36738 }
36739 {
36740 PyThreadState* __tstate = wxPyBeginAllowThreads();
36741 (arg1)->SetDropTarget(arg2);
36742 wxPyEndAllowThreads(__tstate);
36743 if (PyErr_Occurred()) SWIG_fail;
36744 }
36745 resultobj = SWIG_Py_Void();
36746 return resultobj;
36747 fail:
36748 return NULL;
36749 }
36750
36751
36752 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36753 PyObject *resultobj = 0;
36754 wxWindow *arg1 = (wxWindow *) 0 ;
36755 wxPyDropTarget *result = 0 ;
36756 void *argp1 = 0 ;
36757 int res1 = 0 ;
36758 PyObject *swig_obj[1] ;
36759
36760 if (!args) SWIG_fail;
36761 swig_obj[0] = args;
36762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36763 if (!SWIG_IsOK(res1)) {
36764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36765 }
36766 arg1 = reinterpret_cast< wxWindow * >(argp1);
36767 {
36768 PyThreadState* __tstate = wxPyBeginAllowThreads();
36769 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36770 wxPyEndAllowThreads(__tstate);
36771 if (PyErr_Occurred()) SWIG_fail;
36772 }
36773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36781 PyObject *resultobj = 0;
36782 wxWindow *arg1 = (wxWindow *) 0 ;
36783 bool arg2 ;
36784 void *argp1 = 0 ;
36785 int res1 = 0 ;
36786 bool val2 ;
36787 int ecode2 = 0 ;
36788 PyObject * obj0 = 0 ;
36789 PyObject * obj1 = 0 ;
36790 char * kwnames[] = {
36791 (char *) "self",(char *) "accept", NULL
36792 };
36793
36794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36796 if (!SWIG_IsOK(res1)) {
36797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36798 }
36799 arg1 = reinterpret_cast< wxWindow * >(argp1);
36800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36801 if (!SWIG_IsOK(ecode2)) {
36802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36803 }
36804 arg2 = static_cast< bool >(val2);
36805 {
36806 PyThreadState* __tstate = wxPyBeginAllowThreads();
36807 wxWindow_DragAcceptFiles(arg1,arg2);
36808 wxPyEndAllowThreads(__tstate);
36809 if (PyErr_Occurred()) SWIG_fail;
36810 }
36811 resultobj = SWIG_Py_Void();
36812 return resultobj;
36813 fail:
36814 return NULL;
36815 }
36816
36817
36818 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36819 PyObject *resultobj = 0;
36820 wxWindow *arg1 = (wxWindow *) 0 ;
36821 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36822 void *argp1 = 0 ;
36823 int res1 = 0 ;
36824 int res2 = 0 ;
36825 PyObject * obj0 = 0 ;
36826 PyObject * obj1 = 0 ;
36827 char * kwnames[] = {
36828 (char *) "self",(char *) "constraints", NULL
36829 };
36830
36831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36835 }
36836 arg1 = reinterpret_cast< wxWindow * >(argp1);
36837 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36838 if (!SWIG_IsOK(res2)) {
36839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36840 }
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 (arg1)->SetConstraints(arg2);
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 resultobj = SWIG_Py_Void();
36848 return resultobj;
36849 fail:
36850 return NULL;
36851 }
36852
36853
36854 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36855 PyObject *resultobj = 0;
36856 wxWindow *arg1 = (wxWindow *) 0 ;
36857 wxLayoutConstraints *result = 0 ;
36858 void *argp1 = 0 ;
36859 int res1 = 0 ;
36860 PyObject *swig_obj[1] ;
36861
36862 if (!args) SWIG_fail;
36863 swig_obj[0] = args;
36864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36865 if (!SWIG_IsOK(res1)) {
36866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36867 }
36868 arg1 = reinterpret_cast< wxWindow * >(argp1);
36869 {
36870 PyThreadState* __tstate = wxPyBeginAllowThreads();
36871 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
36872 wxPyEndAllowThreads(__tstate);
36873 if (PyErr_Occurred()) SWIG_fail;
36874 }
36875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
36876 return resultobj;
36877 fail:
36878 return NULL;
36879 }
36880
36881
36882 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36883 PyObject *resultobj = 0;
36884 wxWindow *arg1 = (wxWindow *) 0 ;
36885 bool arg2 ;
36886 void *argp1 = 0 ;
36887 int res1 = 0 ;
36888 bool val2 ;
36889 int ecode2 = 0 ;
36890 PyObject * obj0 = 0 ;
36891 PyObject * obj1 = 0 ;
36892 char * kwnames[] = {
36893 (char *) "self",(char *) "autoLayout", NULL
36894 };
36895
36896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
36897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36898 if (!SWIG_IsOK(res1)) {
36899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
36900 }
36901 arg1 = reinterpret_cast< wxWindow * >(argp1);
36902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36903 if (!SWIG_IsOK(ecode2)) {
36904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
36905 }
36906 arg2 = static_cast< bool >(val2);
36907 {
36908 PyThreadState* __tstate = wxPyBeginAllowThreads();
36909 (arg1)->SetAutoLayout(arg2);
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 resultobj = SWIG_Py_Void();
36914 return resultobj;
36915 fail:
36916 return NULL;
36917 }
36918
36919
36920 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36921 PyObject *resultobj = 0;
36922 wxWindow *arg1 = (wxWindow *) 0 ;
36923 bool result;
36924 void *argp1 = 0 ;
36925 int res1 = 0 ;
36926 PyObject *swig_obj[1] ;
36927
36928 if (!args) SWIG_fail;
36929 swig_obj[0] = args;
36930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36931 if (!SWIG_IsOK(res1)) {
36932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
36933 }
36934 arg1 = reinterpret_cast< wxWindow * >(argp1);
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 {
36942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36943 }
36944 return resultobj;
36945 fail:
36946 return NULL;
36947 }
36948
36949
36950 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36951 PyObject *resultobj = 0;
36952 wxWindow *arg1 = (wxWindow *) 0 ;
36953 bool result;
36954 void *argp1 = 0 ;
36955 int res1 = 0 ;
36956 PyObject *swig_obj[1] ;
36957
36958 if (!args) SWIG_fail;
36959 swig_obj[0] = args;
36960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36961 if (!SWIG_IsOK(res1)) {
36962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
36963 }
36964 arg1 = reinterpret_cast< wxWindow * >(argp1);
36965 {
36966 PyThreadState* __tstate = wxPyBeginAllowThreads();
36967 result = (bool)(arg1)->Layout();
36968 wxPyEndAllowThreads(__tstate);
36969 if (PyErr_Occurred()) SWIG_fail;
36970 }
36971 {
36972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36973 }
36974 return resultobj;
36975 fail:
36976 return NULL;
36977 }
36978
36979
36980 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36981 PyObject *resultobj = 0;
36982 wxWindow *arg1 = (wxWindow *) 0 ;
36983 wxSizer *arg2 = (wxSizer *) 0 ;
36984 bool arg3 = (bool) true ;
36985 void *argp1 = 0 ;
36986 int res1 = 0 ;
36987 int res2 = 0 ;
36988 bool val3 ;
36989 int ecode3 = 0 ;
36990 PyObject * obj0 = 0 ;
36991 PyObject * obj1 = 0 ;
36992 PyObject * obj2 = 0 ;
36993 char * kwnames[] = {
36994 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
36995 };
36996
36997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36999 if (!SWIG_IsOK(res1)) {
37000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37001 }
37002 arg1 = reinterpret_cast< wxWindow * >(argp1);
37003 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37004 if (!SWIG_IsOK(res2)) {
37005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37006 }
37007 if (obj2) {
37008 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37009 if (!SWIG_IsOK(ecode3)) {
37010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37011 }
37012 arg3 = static_cast< bool >(val3);
37013 }
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 (arg1)->SetSizer(arg2,arg3);
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 resultobj = SWIG_Py_Void();
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj = 0;
37029 wxWindow *arg1 = (wxWindow *) 0 ;
37030 wxSizer *arg2 = (wxSizer *) 0 ;
37031 bool arg3 = (bool) true ;
37032 void *argp1 = 0 ;
37033 int res1 = 0 ;
37034 int res2 = 0 ;
37035 bool val3 ;
37036 int ecode3 = 0 ;
37037 PyObject * obj0 = 0 ;
37038 PyObject * obj1 = 0 ;
37039 PyObject * obj2 = 0 ;
37040 char * kwnames[] = {
37041 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37042 };
37043
37044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37046 if (!SWIG_IsOK(res1)) {
37047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37048 }
37049 arg1 = reinterpret_cast< wxWindow * >(argp1);
37050 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37051 if (!SWIG_IsOK(res2)) {
37052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37053 }
37054 if (obj2) {
37055 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37056 if (!SWIG_IsOK(ecode3)) {
37057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37058 }
37059 arg3 = static_cast< bool >(val3);
37060 }
37061 {
37062 PyThreadState* __tstate = wxPyBeginAllowThreads();
37063 (arg1)->SetSizerAndFit(arg2,arg3);
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 resultobj = SWIG_Py_Void();
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37075 PyObject *resultobj = 0;
37076 wxWindow *arg1 = (wxWindow *) 0 ;
37077 wxSizer *result = 0 ;
37078 void *argp1 = 0 ;
37079 int res1 = 0 ;
37080 PyObject *swig_obj[1] ;
37081
37082 if (!args) SWIG_fail;
37083 swig_obj[0] = args;
37084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 {
37096 resultobj = wxPyMake_wxObject(result, (bool)0);
37097 }
37098 return resultobj;
37099 fail:
37100 return NULL;
37101 }
37102
37103
37104 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37105 PyObject *resultobj = 0;
37106 wxWindow *arg1 = (wxWindow *) 0 ;
37107 wxSizer *arg2 = (wxSizer *) 0 ;
37108 void *argp1 = 0 ;
37109 int res1 = 0 ;
37110 void *argp2 = 0 ;
37111 int res2 = 0 ;
37112 PyObject * obj0 = 0 ;
37113 PyObject * obj1 = 0 ;
37114 char * kwnames[] = {
37115 (char *) "self",(char *) "sizer", NULL
37116 };
37117
37118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37120 if (!SWIG_IsOK(res1)) {
37121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37122 }
37123 arg1 = reinterpret_cast< wxWindow * >(argp1);
37124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37125 if (!SWIG_IsOK(res2)) {
37126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37127 }
37128 arg2 = reinterpret_cast< wxSizer * >(argp2);
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 (arg1)->SetContainingSizer(arg2);
37132 wxPyEndAllowThreads(__tstate);
37133 if (PyErr_Occurred()) SWIG_fail;
37134 }
37135 resultobj = SWIG_Py_Void();
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37143 PyObject *resultobj = 0;
37144 wxWindow *arg1 = (wxWindow *) 0 ;
37145 wxSizer *result = 0 ;
37146 void *argp1 = 0 ;
37147 int res1 = 0 ;
37148 PyObject *swig_obj[1] ;
37149
37150 if (!args) SWIG_fail;
37151 swig_obj[0] = args;
37152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37153 if (!SWIG_IsOK(res1)) {
37154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37155 }
37156 arg1 = reinterpret_cast< wxWindow * >(argp1);
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 {
37164 resultobj = wxPyMake_wxObject(result, (bool)0);
37165 }
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
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_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 (arg1)->InheritAttributes();
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 resultobj = SWIG_Py_Void();
37193 return resultobj;
37194 fail:
37195 return NULL;
37196 }
37197
37198
37199 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37200 PyObject *resultobj = 0;
37201 wxWindow *arg1 = (wxWindow *) 0 ;
37202 bool result;
37203 void *argp1 = 0 ;
37204 int res1 = 0 ;
37205 PyObject *swig_obj[1] ;
37206
37207 if (!args) SWIG_fail;
37208 swig_obj[0] = args;
37209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37210 if (!SWIG_IsOK(res1)) {
37211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37212 }
37213 arg1 = reinterpret_cast< wxWindow * >(argp1);
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37217 wxPyEndAllowThreads(__tstate);
37218 if (PyErr_Occurred()) SWIG_fail;
37219 }
37220 {
37221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37222 }
37223 return resultobj;
37224 fail:
37225 return NULL;
37226 }
37227
37228
37229 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37230 PyObject *obj;
37231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37232 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37233 return SWIG_Py_Void();
37234 }
37235
37236 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37237 return SWIG_Python_InitShadowInstance(args);
37238 }
37239
37240 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37241 PyObject *resultobj = 0;
37242 long arg1 ;
37243 wxWindow *arg2 = (wxWindow *) NULL ;
37244 wxWindow *result = 0 ;
37245 long val1 ;
37246 int ecode1 = 0 ;
37247 void *argp2 = 0 ;
37248 int res2 = 0 ;
37249 PyObject * obj0 = 0 ;
37250 PyObject * obj1 = 0 ;
37251 char * kwnames[] = {
37252 (char *) "id",(char *) "parent", NULL
37253 };
37254
37255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37256 ecode1 = SWIG_AsVal_long(obj0, &val1);
37257 if (!SWIG_IsOK(ecode1)) {
37258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37259 }
37260 arg1 = static_cast< long >(val1);
37261 if (obj1) {
37262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37263 if (!SWIG_IsOK(res2)) {
37264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37265 }
37266 arg2 = reinterpret_cast< wxWindow * >(argp2);
37267 }
37268 {
37269 if (!wxPyCheckForApp()) SWIG_fail;
37270 PyThreadState* __tstate = wxPyBeginAllowThreads();
37271 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37272 wxPyEndAllowThreads(__tstate);
37273 if (PyErr_Occurred()) SWIG_fail;
37274 }
37275 {
37276 resultobj = wxPyMake_wxObject(result, 0);
37277 }
37278 return resultobj;
37279 fail:
37280 return NULL;
37281 }
37282
37283
37284 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37285 PyObject *resultobj = 0;
37286 wxString *arg1 = 0 ;
37287 wxWindow *arg2 = (wxWindow *) NULL ;
37288 wxWindow *result = 0 ;
37289 bool temp1 = false ;
37290 void *argp2 = 0 ;
37291 int res2 = 0 ;
37292 PyObject * obj0 = 0 ;
37293 PyObject * obj1 = 0 ;
37294 char * kwnames[] = {
37295 (char *) "name",(char *) "parent", NULL
37296 };
37297
37298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37299 {
37300 arg1 = wxString_in_helper(obj0);
37301 if (arg1 == NULL) SWIG_fail;
37302 temp1 = true;
37303 }
37304 if (obj1) {
37305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37306 if (!SWIG_IsOK(res2)) {
37307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37308 }
37309 arg2 = reinterpret_cast< wxWindow * >(argp2);
37310 }
37311 {
37312 if (!wxPyCheckForApp()) SWIG_fail;
37313 PyThreadState* __tstate = wxPyBeginAllowThreads();
37314 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37315 wxPyEndAllowThreads(__tstate);
37316 if (PyErr_Occurred()) SWIG_fail;
37317 }
37318 {
37319 resultobj = wxPyMake_wxObject(result, 0);
37320 }
37321 {
37322 if (temp1)
37323 delete arg1;
37324 }
37325 return resultobj;
37326 fail:
37327 {
37328 if (temp1)
37329 delete arg1;
37330 }
37331 return NULL;
37332 }
37333
37334
37335 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37336 PyObject *resultobj = 0;
37337 wxString *arg1 = 0 ;
37338 wxWindow *arg2 = (wxWindow *) NULL ;
37339 wxWindow *result = 0 ;
37340 bool temp1 = false ;
37341 void *argp2 = 0 ;
37342 int res2 = 0 ;
37343 PyObject * obj0 = 0 ;
37344 PyObject * obj1 = 0 ;
37345 char * kwnames[] = {
37346 (char *) "label",(char *) "parent", NULL
37347 };
37348
37349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37350 {
37351 arg1 = wxString_in_helper(obj0);
37352 if (arg1 == NULL) SWIG_fail;
37353 temp1 = true;
37354 }
37355 if (obj1) {
37356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37357 if (!SWIG_IsOK(res2)) {
37358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37359 }
37360 arg2 = reinterpret_cast< wxWindow * >(argp2);
37361 }
37362 {
37363 if (!wxPyCheckForApp()) SWIG_fail;
37364 PyThreadState* __tstate = wxPyBeginAllowThreads();
37365 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37366 wxPyEndAllowThreads(__tstate);
37367 if (PyErr_Occurred()) SWIG_fail;
37368 }
37369 {
37370 resultobj = wxPyMake_wxObject(result, 0);
37371 }
37372 {
37373 if (temp1)
37374 delete arg1;
37375 }
37376 return resultobj;
37377 fail:
37378 {
37379 if (temp1)
37380 delete arg1;
37381 }
37382 return NULL;
37383 }
37384
37385
37386 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37387 PyObject *resultobj = 0;
37388 wxWindow *arg1 = (wxWindow *) 0 ;
37389 unsigned long arg2 ;
37390 wxWindow *result = 0 ;
37391 void *argp1 = 0 ;
37392 int res1 = 0 ;
37393 unsigned long val2 ;
37394 int ecode2 = 0 ;
37395 PyObject * obj0 = 0 ;
37396 PyObject * obj1 = 0 ;
37397 char * kwnames[] = {
37398 (char *) "parent",(char *) "_hWnd", NULL
37399 };
37400
37401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37403 if (!SWIG_IsOK(res1)) {
37404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37405 }
37406 arg1 = reinterpret_cast< wxWindow * >(argp1);
37407 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37408 if (!SWIG_IsOK(ecode2)) {
37409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37410 }
37411 arg2 = static_cast< unsigned long >(val2);
37412 {
37413 PyThreadState* __tstate = wxPyBeginAllowThreads();
37414 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37415 wxPyEndAllowThreads(__tstate);
37416 if (PyErr_Occurred()) SWIG_fail;
37417 }
37418 {
37419 resultobj = wxPyMake_wxObject(result, 0);
37420 }
37421 return resultobj;
37422 fail:
37423 return NULL;
37424 }
37425
37426
37427 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37428 PyObject *resultobj = 0;
37429 PyObject *result = 0 ;
37430
37431 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37432 {
37433 PyThreadState* __tstate = wxPyBeginAllowThreads();
37434 result = (PyObject *)GetTopLevelWindows();
37435 wxPyEndAllowThreads(__tstate);
37436 if (PyErr_Occurred()) SWIG_fail;
37437 }
37438 resultobj = result;
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37446 PyObject *resultobj = 0;
37447 wxValidator *result = 0 ;
37448
37449 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37450 {
37451 PyThreadState* __tstate = wxPyBeginAllowThreads();
37452 result = (wxValidator *)new wxValidator();
37453 wxPyEndAllowThreads(__tstate);
37454 if (PyErr_Occurred()) SWIG_fail;
37455 }
37456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37457 return resultobj;
37458 fail:
37459 return NULL;
37460 }
37461
37462
37463 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37464 PyObject *resultobj = 0;
37465 wxValidator *arg1 = (wxValidator *) 0 ;
37466 wxValidator *result = 0 ;
37467 void *argp1 = 0 ;
37468 int res1 = 0 ;
37469 PyObject *swig_obj[1] ;
37470
37471 if (!args) SWIG_fail;
37472 swig_obj[0] = args;
37473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37474 if (!SWIG_IsOK(res1)) {
37475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37476 }
37477 arg1 = reinterpret_cast< wxValidator * >(argp1);
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 result = (wxValidator *)(arg1)->Clone();
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 {
37485 resultobj = wxPyMake_wxObject(result, 0);
37486 }
37487 return resultobj;
37488 fail:
37489 return NULL;
37490 }
37491
37492
37493 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37494 PyObject *resultobj = 0;
37495 wxValidator *arg1 = (wxValidator *) 0 ;
37496 wxWindow *arg2 = (wxWindow *) 0 ;
37497 bool result;
37498 void *argp1 = 0 ;
37499 int res1 = 0 ;
37500 void *argp2 = 0 ;
37501 int res2 = 0 ;
37502 PyObject * obj0 = 0 ;
37503 PyObject * obj1 = 0 ;
37504 char * kwnames[] = {
37505 (char *) "self",(char *) "parent", NULL
37506 };
37507
37508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37512 }
37513 arg1 = reinterpret_cast< wxValidator * >(argp1);
37514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37515 if (!SWIG_IsOK(res2)) {
37516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37517 }
37518 arg2 = reinterpret_cast< wxWindow * >(argp2);
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 result = (bool)(arg1)->Validate(arg2);
37522 wxPyEndAllowThreads(__tstate);
37523 if (PyErr_Occurred()) SWIG_fail;
37524 }
37525 {
37526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37527 }
37528 return resultobj;
37529 fail:
37530 return NULL;
37531 }
37532
37533
37534 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37535 PyObject *resultobj = 0;
37536 wxValidator *arg1 = (wxValidator *) 0 ;
37537 bool result;
37538 void *argp1 = 0 ;
37539 int res1 = 0 ;
37540 PyObject *swig_obj[1] ;
37541
37542 if (!args) SWIG_fail;
37543 swig_obj[0] = args;
37544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37545 if (!SWIG_IsOK(res1)) {
37546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37547 }
37548 arg1 = reinterpret_cast< wxValidator * >(argp1);
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 result = (bool)(arg1)->TransferToWindow();
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 {
37556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37557 }
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37565 PyObject *resultobj = 0;
37566 wxValidator *arg1 = (wxValidator *) 0 ;
37567 bool result;
37568 void *argp1 = 0 ;
37569 int res1 = 0 ;
37570 PyObject *swig_obj[1] ;
37571
37572 if (!args) SWIG_fail;
37573 swig_obj[0] = args;
37574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37575 if (!SWIG_IsOK(res1)) {
37576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37577 }
37578 arg1 = reinterpret_cast< wxValidator * >(argp1);
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = (bool)(arg1)->TransferFromWindow();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 {
37586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37587 }
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37595 PyObject *resultobj = 0;
37596 wxValidator *arg1 = (wxValidator *) 0 ;
37597 wxWindow *result = 0 ;
37598 void *argp1 = 0 ;
37599 int res1 = 0 ;
37600 PyObject *swig_obj[1] ;
37601
37602 if (!args) SWIG_fail;
37603 swig_obj[0] = args;
37604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37607 }
37608 arg1 = reinterpret_cast< wxValidator * >(argp1);
37609 {
37610 PyThreadState* __tstate = wxPyBeginAllowThreads();
37611 result = (wxWindow *)(arg1)->GetWindow();
37612 wxPyEndAllowThreads(__tstate);
37613 if (PyErr_Occurred()) SWIG_fail;
37614 }
37615 {
37616 resultobj = wxPyMake_wxObject(result, 0);
37617 }
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37625 PyObject *resultobj = 0;
37626 wxValidator *arg1 = (wxValidator *) 0 ;
37627 wxWindow *arg2 = (wxWindow *) 0 ;
37628 void *argp1 = 0 ;
37629 int res1 = 0 ;
37630 void *argp2 = 0 ;
37631 int res2 = 0 ;
37632 PyObject * obj0 = 0 ;
37633 PyObject * obj1 = 0 ;
37634 char * kwnames[] = {
37635 (char *) "self",(char *) "window", NULL
37636 };
37637
37638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37640 if (!SWIG_IsOK(res1)) {
37641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37642 }
37643 arg1 = reinterpret_cast< wxValidator * >(argp1);
37644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37645 if (!SWIG_IsOK(res2)) {
37646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37647 }
37648 arg2 = reinterpret_cast< wxWindow * >(argp2);
37649 {
37650 PyThreadState* __tstate = wxPyBeginAllowThreads();
37651 (arg1)->SetWindow(arg2);
37652 wxPyEndAllowThreads(__tstate);
37653 if (PyErr_Occurred()) SWIG_fail;
37654 }
37655 resultobj = SWIG_Py_Void();
37656 return resultobj;
37657 fail:
37658 return NULL;
37659 }
37660
37661
37662 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37663 PyObject *resultobj = 0;
37664 bool result;
37665
37666 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37667 {
37668 PyThreadState* __tstate = wxPyBeginAllowThreads();
37669 result = (bool)wxValidator::IsSilent();
37670 wxPyEndAllowThreads(__tstate);
37671 if (PyErr_Occurred()) SWIG_fail;
37672 }
37673 {
37674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37675 }
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37683 PyObject *resultobj = 0;
37684 int arg1 = (int) true ;
37685 int val1 ;
37686 int ecode1 = 0 ;
37687 PyObject * obj0 = 0 ;
37688 char * kwnames[] = {
37689 (char *) "doIt", NULL
37690 };
37691
37692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37693 if (obj0) {
37694 ecode1 = SWIG_AsVal_int(obj0, &val1);
37695 if (!SWIG_IsOK(ecode1)) {
37696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37697 }
37698 arg1 = static_cast< int >(val1);
37699 }
37700 {
37701 PyThreadState* __tstate = wxPyBeginAllowThreads();
37702 wxValidator::SetBellOnError(arg1);
37703 wxPyEndAllowThreads(__tstate);
37704 if (PyErr_Occurred()) SWIG_fail;
37705 }
37706 resultobj = SWIG_Py_Void();
37707 return resultobj;
37708 fail:
37709 return NULL;
37710 }
37711
37712
37713 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37714 PyObject *obj;
37715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37716 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37717 return SWIG_Py_Void();
37718 }
37719
37720 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37721 return SWIG_Python_InitShadowInstance(args);
37722 }
37723
37724 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37725 PyObject *resultobj = 0;
37726 wxPyValidator *result = 0 ;
37727
37728 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37729 {
37730 PyThreadState* __tstate = wxPyBeginAllowThreads();
37731 result = (wxPyValidator *)new wxPyValidator();
37732 wxPyEndAllowThreads(__tstate);
37733 if (PyErr_Occurred()) SWIG_fail;
37734 }
37735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37736 return resultobj;
37737 fail:
37738 return NULL;
37739 }
37740
37741
37742 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37743 PyObject *resultobj = 0;
37744 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37745 PyObject *arg2 = (PyObject *) 0 ;
37746 PyObject *arg3 = (PyObject *) 0 ;
37747 int arg4 = (int) true ;
37748 void *argp1 = 0 ;
37749 int res1 = 0 ;
37750 int val4 ;
37751 int ecode4 = 0 ;
37752 PyObject * obj0 = 0 ;
37753 PyObject * obj1 = 0 ;
37754 PyObject * obj2 = 0 ;
37755 PyObject * obj3 = 0 ;
37756 char * kwnames[] = {
37757 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37758 };
37759
37760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37762 if (!SWIG_IsOK(res1)) {
37763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37764 }
37765 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37766 arg2 = obj1;
37767 arg3 = obj2;
37768 if (obj3) {
37769 ecode4 = SWIG_AsVal_int(obj3, &val4);
37770 if (!SWIG_IsOK(ecode4)) {
37771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37772 }
37773 arg4 = static_cast< int >(val4);
37774 }
37775 {
37776 PyThreadState* __tstate = wxPyBeginAllowThreads();
37777 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37778 wxPyEndAllowThreads(__tstate);
37779 if (PyErr_Occurred()) SWIG_fail;
37780 }
37781 resultobj = SWIG_Py_Void();
37782 return resultobj;
37783 fail:
37784 return NULL;
37785 }
37786
37787
37788 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37789 PyObject *obj;
37790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37791 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37792 return SWIG_Py_Void();
37793 }
37794
37795 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37796 return SWIG_Python_InitShadowInstance(args);
37797 }
37798
37799 SWIGINTERN int DefaultValidator_set(PyObject *) {
37800 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37801 return 1;
37802 }
37803
37804
37805 SWIGINTERN PyObject *DefaultValidator_get(void) {
37806 PyObject *pyobj = 0;
37807
37808 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37809 return pyobj;
37810 }
37811
37812
37813 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37814 PyObject *resultobj = 0;
37815 wxString const &arg1_defvalue = wxPyEmptyString ;
37816 wxString *arg1 = (wxString *) &arg1_defvalue ;
37817 long arg2 = (long) 0 ;
37818 wxMenu *result = 0 ;
37819 bool temp1 = false ;
37820 long val2 ;
37821 int ecode2 = 0 ;
37822 PyObject * obj0 = 0 ;
37823 PyObject * obj1 = 0 ;
37824 char * kwnames[] = {
37825 (char *) "title",(char *) "style", NULL
37826 };
37827
37828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37829 if (obj0) {
37830 {
37831 arg1 = wxString_in_helper(obj0);
37832 if (arg1 == NULL) SWIG_fail;
37833 temp1 = true;
37834 }
37835 }
37836 if (obj1) {
37837 ecode2 = SWIG_AsVal_long(obj1, &val2);
37838 if (!SWIG_IsOK(ecode2)) {
37839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37840 }
37841 arg2 = static_cast< long >(val2);
37842 }
37843 {
37844 if (!wxPyCheckForApp()) SWIG_fail;
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37851 {
37852 if (temp1)
37853 delete arg1;
37854 }
37855 return resultobj;
37856 fail:
37857 {
37858 if (temp1)
37859 delete arg1;
37860 }
37861 return NULL;
37862 }
37863
37864
37865 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37866 PyObject *resultobj = 0;
37867 wxMenu *arg1 = (wxMenu *) 0 ;
37868 int arg2 ;
37869 wxString *arg3 = 0 ;
37870 wxString const &arg4_defvalue = wxPyEmptyString ;
37871 wxString *arg4 = (wxString *) &arg4_defvalue ;
37872 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
37873 wxMenuItem *result = 0 ;
37874 void *argp1 = 0 ;
37875 int res1 = 0 ;
37876 int val2 ;
37877 int ecode2 = 0 ;
37878 bool temp3 = false ;
37879 bool temp4 = false ;
37880 int val5 ;
37881 int ecode5 = 0 ;
37882 PyObject * obj0 = 0 ;
37883 PyObject * obj1 = 0 ;
37884 PyObject * obj2 = 0 ;
37885 PyObject * obj3 = 0 ;
37886 PyObject * obj4 = 0 ;
37887 char * kwnames[] = {
37888 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
37889 };
37890
37891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
37895 }
37896 arg1 = reinterpret_cast< wxMenu * >(argp1);
37897 ecode2 = SWIG_AsVal_int(obj1, &val2);
37898 if (!SWIG_IsOK(ecode2)) {
37899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
37900 }
37901 arg2 = static_cast< int >(val2);
37902 {
37903 arg3 = wxString_in_helper(obj2);
37904 if (arg3 == NULL) SWIG_fail;
37905 temp3 = true;
37906 }
37907 if (obj3) {
37908 {
37909 arg4 = wxString_in_helper(obj3);
37910 if (arg4 == NULL) SWIG_fail;
37911 temp4 = true;
37912 }
37913 }
37914 if (obj4) {
37915 ecode5 = SWIG_AsVal_int(obj4, &val5);
37916 if (!SWIG_IsOK(ecode5)) {
37917 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
37918 }
37919 arg5 = static_cast< wxItemKind >(val5);
37920 }
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 {
37928 resultobj = wxPyMake_wxObject(result, (bool)0);
37929 }
37930 {
37931 if (temp3)
37932 delete arg3;
37933 }
37934 {
37935 if (temp4)
37936 delete arg4;
37937 }
37938 return resultobj;
37939 fail:
37940 {
37941 if (temp3)
37942 delete arg3;
37943 }
37944 {
37945 if (temp4)
37946 delete arg4;
37947 }
37948 return NULL;
37949 }
37950
37951
37952 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37953 PyObject *resultobj = 0;
37954 wxMenu *arg1 = (wxMenu *) 0 ;
37955 wxMenuItem *result = 0 ;
37956 void *argp1 = 0 ;
37957 int res1 = 0 ;
37958 PyObject *swig_obj[1] ;
37959
37960 if (!args) SWIG_fail;
37961 swig_obj[0] = args;
37962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37963 if (!SWIG_IsOK(res1)) {
37964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
37965 }
37966 arg1 = reinterpret_cast< wxMenu * >(argp1);
37967 {
37968 PyThreadState* __tstate = wxPyBeginAllowThreads();
37969 result = (wxMenuItem *)(arg1)->AppendSeparator();
37970 wxPyEndAllowThreads(__tstate);
37971 if (PyErr_Occurred()) SWIG_fail;
37972 }
37973 {
37974 resultobj = wxPyMake_wxObject(result, (bool)0);
37975 }
37976 return resultobj;
37977 fail:
37978 return NULL;
37979 }
37980
37981
37982 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37983 PyObject *resultobj = 0;
37984 wxMenu *arg1 = (wxMenu *) 0 ;
37985 int arg2 ;
37986 wxString *arg3 = 0 ;
37987 wxString const &arg4_defvalue = wxPyEmptyString ;
37988 wxString *arg4 = (wxString *) &arg4_defvalue ;
37989 wxMenuItem *result = 0 ;
37990 void *argp1 = 0 ;
37991 int res1 = 0 ;
37992 int val2 ;
37993 int ecode2 = 0 ;
37994 bool temp3 = false ;
37995 bool temp4 = false ;
37996 PyObject * obj0 = 0 ;
37997 PyObject * obj1 = 0 ;
37998 PyObject * obj2 = 0 ;
37999 PyObject * obj3 = 0 ;
38000 char * kwnames[] = {
38001 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38002 };
38003
38004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38006 if (!SWIG_IsOK(res1)) {
38007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38008 }
38009 arg1 = reinterpret_cast< wxMenu * >(argp1);
38010 ecode2 = SWIG_AsVal_int(obj1, &val2);
38011 if (!SWIG_IsOK(ecode2)) {
38012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38013 }
38014 arg2 = static_cast< int >(val2);
38015 {
38016 arg3 = wxString_in_helper(obj2);
38017 if (arg3 == NULL) SWIG_fail;
38018 temp3 = true;
38019 }
38020 if (obj3) {
38021 {
38022 arg4 = wxString_in_helper(obj3);
38023 if (arg4 == NULL) SWIG_fail;
38024 temp4 = true;
38025 }
38026 }
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 {
38034 resultobj = wxPyMake_wxObject(result, (bool)0);
38035 }
38036 {
38037 if (temp3)
38038 delete arg3;
38039 }
38040 {
38041 if (temp4)
38042 delete arg4;
38043 }
38044 return resultobj;
38045 fail:
38046 {
38047 if (temp3)
38048 delete arg3;
38049 }
38050 {
38051 if (temp4)
38052 delete arg4;
38053 }
38054 return NULL;
38055 }
38056
38057
38058 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38059 PyObject *resultobj = 0;
38060 wxMenu *arg1 = (wxMenu *) 0 ;
38061 int arg2 ;
38062 wxString *arg3 = 0 ;
38063 wxString const &arg4_defvalue = wxPyEmptyString ;
38064 wxString *arg4 = (wxString *) &arg4_defvalue ;
38065 wxMenuItem *result = 0 ;
38066 void *argp1 = 0 ;
38067 int res1 = 0 ;
38068 int val2 ;
38069 int ecode2 = 0 ;
38070 bool temp3 = false ;
38071 bool temp4 = false ;
38072 PyObject * obj0 = 0 ;
38073 PyObject * obj1 = 0 ;
38074 PyObject * obj2 = 0 ;
38075 PyObject * obj3 = 0 ;
38076 char * kwnames[] = {
38077 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38078 };
38079
38080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38082 if (!SWIG_IsOK(res1)) {
38083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38084 }
38085 arg1 = reinterpret_cast< wxMenu * >(argp1);
38086 ecode2 = SWIG_AsVal_int(obj1, &val2);
38087 if (!SWIG_IsOK(ecode2)) {
38088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38089 }
38090 arg2 = static_cast< int >(val2);
38091 {
38092 arg3 = wxString_in_helper(obj2);
38093 if (arg3 == NULL) SWIG_fail;
38094 temp3 = true;
38095 }
38096 if (obj3) {
38097 {
38098 arg4 = wxString_in_helper(obj3);
38099 if (arg4 == NULL) SWIG_fail;
38100 temp4 = true;
38101 }
38102 }
38103 {
38104 PyThreadState* __tstate = wxPyBeginAllowThreads();
38105 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38106 wxPyEndAllowThreads(__tstate);
38107 if (PyErr_Occurred()) SWIG_fail;
38108 }
38109 {
38110 resultobj = wxPyMake_wxObject(result, (bool)0);
38111 }
38112 {
38113 if (temp3)
38114 delete arg3;
38115 }
38116 {
38117 if (temp4)
38118 delete arg4;
38119 }
38120 return resultobj;
38121 fail:
38122 {
38123 if (temp3)
38124 delete arg3;
38125 }
38126 {
38127 if (temp4)
38128 delete arg4;
38129 }
38130 return NULL;
38131 }
38132
38133
38134 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38135 PyObject *resultobj = 0;
38136 wxMenu *arg1 = (wxMenu *) 0 ;
38137 int arg2 ;
38138 wxString *arg3 = 0 ;
38139 wxMenu *arg4 = (wxMenu *) 0 ;
38140 wxString const &arg5_defvalue = wxPyEmptyString ;
38141 wxString *arg5 = (wxString *) &arg5_defvalue ;
38142 wxMenuItem *result = 0 ;
38143 void *argp1 = 0 ;
38144 int res1 = 0 ;
38145 int val2 ;
38146 int ecode2 = 0 ;
38147 bool temp3 = false ;
38148 void *argp4 = 0 ;
38149 int res4 = 0 ;
38150 bool temp5 = false ;
38151 PyObject * obj0 = 0 ;
38152 PyObject * obj1 = 0 ;
38153 PyObject * obj2 = 0 ;
38154 PyObject * obj3 = 0 ;
38155 PyObject * obj4 = 0 ;
38156 char * kwnames[] = {
38157 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38158 };
38159
38160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38162 if (!SWIG_IsOK(res1)) {
38163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38164 }
38165 arg1 = reinterpret_cast< wxMenu * >(argp1);
38166 ecode2 = SWIG_AsVal_int(obj1, &val2);
38167 if (!SWIG_IsOK(ecode2)) {
38168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38169 }
38170 arg2 = static_cast< int >(val2);
38171 {
38172 arg3 = wxString_in_helper(obj2);
38173 if (arg3 == NULL) SWIG_fail;
38174 temp3 = true;
38175 }
38176 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38177 if (!SWIG_IsOK(res4)) {
38178 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38179 }
38180 arg4 = reinterpret_cast< wxMenu * >(argp4);
38181 if (obj4) {
38182 {
38183 arg5 = wxString_in_helper(obj4);
38184 if (arg5 == NULL) SWIG_fail;
38185 temp5 = true;
38186 }
38187 }
38188 {
38189 PyThreadState* __tstate = wxPyBeginAllowThreads();
38190 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 {
38195 resultobj = wxPyMake_wxObject(result, (bool)0);
38196 }
38197 {
38198 if (temp3)
38199 delete arg3;
38200 }
38201 {
38202 if (temp5)
38203 delete arg5;
38204 }
38205 return resultobj;
38206 fail:
38207 {
38208 if (temp3)
38209 delete arg3;
38210 }
38211 {
38212 if (temp5)
38213 delete arg5;
38214 }
38215 return NULL;
38216 }
38217
38218
38219 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38220 PyObject *resultobj = 0;
38221 wxMenu *arg1 = (wxMenu *) 0 ;
38222 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38223 wxMenuItem *result = 0 ;
38224 void *argp1 = 0 ;
38225 int res1 = 0 ;
38226 int res2 = 0 ;
38227 PyObject * obj0 = 0 ;
38228 PyObject * obj1 = 0 ;
38229 char * kwnames[] = {
38230 (char *) "self",(char *) "item", NULL
38231 };
38232
38233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38235 if (!SWIG_IsOK(res1)) {
38236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38237 }
38238 arg1 = reinterpret_cast< wxMenu * >(argp1);
38239 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38240 if (!SWIG_IsOK(res2)) {
38241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38242 }
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = (wxMenuItem *)(arg1)->Append(arg2);
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 {
38250 resultobj = wxPyMake_wxObject(result, (bool)0);
38251 }
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38259 PyObject *resultobj = 0;
38260 wxMenu *arg1 = (wxMenu *) 0 ;
38261 size_t arg2 ;
38262 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38263 wxMenuItem *result = 0 ;
38264 void *argp1 = 0 ;
38265 int res1 = 0 ;
38266 size_t val2 ;
38267 int ecode2 = 0 ;
38268 int res3 = 0 ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 PyObject * obj2 = 0 ;
38272 char * kwnames[] = {
38273 (char *) "self",(char *) "pos",(char *) "item", NULL
38274 };
38275
38276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38278 if (!SWIG_IsOK(res1)) {
38279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38280 }
38281 arg1 = reinterpret_cast< wxMenu * >(argp1);
38282 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38283 if (!SWIG_IsOK(ecode2)) {
38284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38285 }
38286 arg2 = static_cast< size_t >(val2);
38287 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38288 if (!SWIG_IsOK(res3)) {
38289 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38290 }
38291 {
38292 PyThreadState* __tstate = wxPyBeginAllowThreads();
38293 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 {
38298 resultobj = wxPyMake_wxObject(result, (bool)0);
38299 }
38300 return resultobj;
38301 fail:
38302 return NULL;
38303 }
38304
38305
38306 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38307 PyObject *resultobj = 0;
38308 wxMenu *arg1 = (wxMenu *) 0 ;
38309 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38310 wxMenuItem *result = 0 ;
38311 void *argp1 = 0 ;
38312 int res1 = 0 ;
38313 int res2 = 0 ;
38314 PyObject * obj0 = 0 ;
38315 PyObject * obj1 = 0 ;
38316 char * kwnames[] = {
38317 (char *) "self",(char *) "item", NULL
38318 };
38319
38320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38322 if (!SWIG_IsOK(res1)) {
38323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38324 }
38325 arg1 = reinterpret_cast< wxMenu * >(argp1);
38326 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38327 if (!SWIG_IsOK(res2)) {
38328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38329 }
38330 {
38331 PyThreadState* __tstate = wxPyBeginAllowThreads();
38332 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38333 wxPyEndAllowThreads(__tstate);
38334 if (PyErr_Occurred()) SWIG_fail;
38335 }
38336 {
38337 resultobj = wxPyMake_wxObject(result, (bool)0);
38338 }
38339 return resultobj;
38340 fail:
38341 return NULL;
38342 }
38343
38344
38345 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38346 PyObject *resultobj = 0;
38347 wxMenu *arg1 = (wxMenu *) 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 PyObject *swig_obj[1] ;
38351
38352 if (!args) SWIG_fail;
38353 swig_obj[0] = args;
38354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38357 }
38358 arg1 = reinterpret_cast< wxMenu * >(argp1);
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 (arg1)->Break();
38362 wxPyEndAllowThreads(__tstate);
38363 if (PyErr_Occurred()) SWIG_fail;
38364 }
38365 resultobj = SWIG_Py_Void();
38366 return resultobj;
38367 fail:
38368 return NULL;
38369 }
38370
38371
38372 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38373 PyObject *resultobj = 0;
38374 wxMenu *arg1 = (wxMenu *) 0 ;
38375 size_t arg2 ;
38376 int arg3 ;
38377 wxString *arg4 = 0 ;
38378 wxString const &arg5_defvalue = wxPyEmptyString ;
38379 wxString *arg5 = (wxString *) &arg5_defvalue ;
38380 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38381 wxMenuItem *result = 0 ;
38382 void *argp1 = 0 ;
38383 int res1 = 0 ;
38384 size_t val2 ;
38385 int ecode2 = 0 ;
38386 int val3 ;
38387 int ecode3 = 0 ;
38388 bool temp4 = false ;
38389 bool temp5 = false ;
38390 int val6 ;
38391 int ecode6 = 0 ;
38392 PyObject * obj0 = 0 ;
38393 PyObject * obj1 = 0 ;
38394 PyObject * obj2 = 0 ;
38395 PyObject * obj3 = 0 ;
38396 PyObject * obj4 = 0 ;
38397 PyObject * obj5 = 0 ;
38398 char * kwnames[] = {
38399 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38400 };
38401
38402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38404 if (!SWIG_IsOK(res1)) {
38405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38406 }
38407 arg1 = reinterpret_cast< wxMenu * >(argp1);
38408 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38409 if (!SWIG_IsOK(ecode2)) {
38410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38411 }
38412 arg2 = static_cast< size_t >(val2);
38413 ecode3 = SWIG_AsVal_int(obj2, &val3);
38414 if (!SWIG_IsOK(ecode3)) {
38415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38416 }
38417 arg3 = static_cast< int >(val3);
38418 {
38419 arg4 = wxString_in_helper(obj3);
38420 if (arg4 == NULL) SWIG_fail;
38421 temp4 = true;
38422 }
38423 if (obj4) {
38424 {
38425 arg5 = wxString_in_helper(obj4);
38426 if (arg5 == NULL) SWIG_fail;
38427 temp5 = true;
38428 }
38429 }
38430 if (obj5) {
38431 ecode6 = SWIG_AsVal_int(obj5, &val6);
38432 if (!SWIG_IsOK(ecode6)) {
38433 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38434 }
38435 arg6 = static_cast< wxItemKind >(val6);
38436 }
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38440 wxPyEndAllowThreads(__tstate);
38441 if (PyErr_Occurred()) SWIG_fail;
38442 }
38443 {
38444 resultobj = wxPyMake_wxObject(result, (bool)0);
38445 }
38446 {
38447 if (temp4)
38448 delete arg4;
38449 }
38450 {
38451 if (temp5)
38452 delete arg5;
38453 }
38454 return resultobj;
38455 fail:
38456 {
38457 if (temp4)
38458 delete arg4;
38459 }
38460 {
38461 if (temp5)
38462 delete arg5;
38463 }
38464 return NULL;
38465 }
38466
38467
38468 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38469 PyObject *resultobj = 0;
38470 wxMenu *arg1 = (wxMenu *) 0 ;
38471 size_t arg2 ;
38472 wxMenuItem *result = 0 ;
38473 void *argp1 = 0 ;
38474 int res1 = 0 ;
38475 size_t val2 ;
38476 int ecode2 = 0 ;
38477 PyObject * obj0 = 0 ;
38478 PyObject * obj1 = 0 ;
38479 char * kwnames[] = {
38480 (char *) "self",(char *) "pos", NULL
38481 };
38482
38483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38485 if (!SWIG_IsOK(res1)) {
38486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38487 }
38488 arg1 = reinterpret_cast< wxMenu * >(argp1);
38489 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38490 if (!SWIG_IsOK(ecode2)) {
38491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38492 }
38493 arg2 = static_cast< size_t >(val2);
38494 {
38495 PyThreadState* __tstate = wxPyBeginAllowThreads();
38496 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38497 wxPyEndAllowThreads(__tstate);
38498 if (PyErr_Occurred()) SWIG_fail;
38499 }
38500 {
38501 resultobj = wxPyMake_wxObject(result, (bool)0);
38502 }
38503 return resultobj;
38504 fail:
38505 return NULL;
38506 }
38507
38508
38509 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38510 PyObject *resultobj = 0;
38511 wxMenu *arg1 = (wxMenu *) 0 ;
38512 size_t arg2 ;
38513 int arg3 ;
38514 wxString *arg4 = 0 ;
38515 wxString const &arg5_defvalue = wxPyEmptyString ;
38516 wxString *arg5 = (wxString *) &arg5_defvalue ;
38517 wxMenuItem *result = 0 ;
38518 void *argp1 = 0 ;
38519 int res1 = 0 ;
38520 size_t val2 ;
38521 int ecode2 = 0 ;
38522 int val3 ;
38523 int ecode3 = 0 ;
38524 bool temp4 = false ;
38525 bool temp5 = false ;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 PyObject * obj2 = 0 ;
38529 PyObject * obj3 = 0 ;
38530 PyObject * obj4 = 0 ;
38531 char * kwnames[] = {
38532 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38533 };
38534
38535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38537 if (!SWIG_IsOK(res1)) {
38538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38539 }
38540 arg1 = reinterpret_cast< wxMenu * >(argp1);
38541 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38542 if (!SWIG_IsOK(ecode2)) {
38543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38544 }
38545 arg2 = static_cast< size_t >(val2);
38546 ecode3 = SWIG_AsVal_int(obj2, &val3);
38547 if (!SWIG_IsOK(ecode3)) {
38548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38549 }
38550 arg3 = static_cast< int >(val3);
38551 {
38552 arg4 = wxString_in_helper(obj3);
38553 if (arg4 == NULL) SWIG_fail;
38554 temp4 = true;
38555 }
38556 if (obj4) {
38557 {
38558 arg5 = wxString_in_helper(obj4);
38559 if (arg5 == NULL) SWIG_fail;
38560 temp5 = true;
38561 }
38562 }
38563 {
38564 PyThreadState* __tstate = wxPyBeginAllowThreads();
38565 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 {
38570 resultobj = wxPyMake_wxObject(result, (bool)0);
38571 }
38572 {
38573 if (temp4)
38574 delete arg4;
38575 }
38576 {
38577 if (temp5)
38578 delete arg5;
38579 }
38580 return resultobj;
38581 fail:
38582 {
38583 if (temp4)
38584 delete arg4;
38585 }
38586 {
38587 if (temp5)
38588 delete arg5;
38589 }
38590 return NULL;
38591 }
38592
38593
38594 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj = 0;
38596 wxMenu *arg1 = (wxMenu *) 0 ;
38597 size_t arg2 ;
38598 int arg3 ;
38599 wxString *arg4 = 0 ;
38600 wxString const &arg5_defvalue = wxPyEmptyString ;
38601 wxString *arg5 = (wxString *) &arg5_defvalue ;
38602 wxMenuItem *result = 0 ;
38603 void *argp1 = 0 ;
38604 int res1 = 0 ;
38605 size_t val2 ;
38606 int ecode2 = 0 ;
38607 int val3 ;
38608 int ecode3 = 0 ;
38609 bool temp4 = false ;
38610 bool temp5 = false ;
38611 PyObject * obj0 = 0 ;
38612 PyObject * obj1 = 0 ;
38613 PyObject * obj2 = 0 ;
38614 PyObject * obj3 = 0 ;
38615 PyObject * obj4 = 0 ;
38616 char * kwnames[] = {
38617 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38618 };
38619
38620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38622 if (!SWIG_IsOK(res1)) {
38623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38624 }
38625 arg1 = reinterpret_cast< wxMenu * >(argp1);
38626 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38627 if (!SWIG_IsOK(ecode2)) {
38628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38629 }
38630 arg2 = static_cast< size_t >(val2);
38631 ecode3 = SWIG_AsVal_int(obj2, &val3);
38632 if (!SWIG_IsOK(ecode3)) {
38633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38634 }
38635 arg3 = static_cast< int >(val3);
38636 {
38637 arg4 = wxString_in_helper(obj3);
38638 if (arg4 == NULL) SWIG_fail;
38639 temp4 = true;
38640 }
38641 if (obj4) {
38642 {
38643 arg5 = wxString_in_helper(obj4);
38644 if (arg5 == NULL) SWIG_fail;
38645 temp5 = true;
38646 }
38647 }
38648 {
38649 PyThreadState* __tstate = wxPyBeginAllowThreads();
38650 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38651 wxPyEndAllowThreads(__tstate);
38652 if (PyErr_Occurred()) SWIG_fail;
38653 }
38654 {
38655 resultobj = wxPyMake_wxObject(result, (bool)0);
38656 }
38657 {
38658 if (temp4)
38659 delete arg4;
38660 }
38661 {
38662 if (temp5)
38663 delete arg5;
38664 }
38665 return resultobj;
38666 fail:
38667 {
38668 if (temp4)
38669 delete arg4;
38670 }
38671 {
38672 if (temp5)
38673 delete arg5;
38674 }
38675 return NULL;
38676 }
38677
38678
38679 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38680 PyObject *resultobj = 0;
38681 wxMenu *arg1 = (wxMenu *) 0 ;
38682 size_t arg2 ;
38683 int arg3 ;
38684 wxString *arg4 = 0 ;
38685 wxMenu *arg5 = (wxMenu *) 0 ;
38686 wxString const &arg6_defvalue = wxPyEmptyString ;
38687 wxString *arg6 = (wxString *) &arg6_defvalue ;
38688 wxMenuItem *result = 0 ;
38689 void *argp1 = 0 ;
38690 int res1 = 0 ;
38691 size_t val2 ;
38692 int ecode2 = 0 ;
38693 int val3 ;
38694 int ecode3 = 0 ;
38695 bool temp4 = false ;
38696 void *argp5 = 0 ;
38697 int res5 = 0 ;
38698 bool temp6 = false ;
38699 PyObject * obj0 = 0 ;
38700 PyObject * obj1 = 0 ;
38701 PyObject * obj2 = 0 ;
38702 PyObject * obj3 = 0 ;
38703 PyObject * obj4 = 0 ;
38704 PyObject * obj5 = 0 ;
38705 char * kwnames[] = {
38706 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38707 };
38708
38709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38711 if (!SWIG_IsOK(res1)) {
38712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38713 }
38714 arg1 = reinterpret_cast< wxMenu * >(argp1);
38715 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38716 if (!SWIG_IsOK(ecode2)) {
38717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38718 }
38719 arg2 = static_cast< size_t >(val2);
38720 ecode3 = SWIG_AsVal_int(obj2, &val3);
38721 if (!SWIG_IsOK(ecode3)) {
38722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38723 }
38724 arg3 = static_cast< int >(val3);
38725 {
38726 arg4 = wxString_in_helper(obj3);
38727 if (arg4 == NULL) SWIG_fail;
38728 temp4 = true;
38729 }
38730 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38731 if (!SWIG_IsOK(res5)) {
38732 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38733 }
38734 arg5 = reinterpret_cast< wxMenu * >(argp5);
38735 if (obj5) {
38736 {
38737 arg6 = wxString_in_helper(obj5);
38738 if (arg6 == NULL) SWIG_fail;
38739 temp6 = true;
38740 }
38741 }
38742 {
38743 PyThreadState* __tstate = wxPyBeginAllowThreads();
38744 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 {
38749 resultobj = wxPyMake_wxObject(result, (bool)0);
38750 }
38751 {
38752 if (temp4)
38753 delete arg4;
38754 }
38755 {
38756 if (temp6)
38757 delete arg6;
38758 }
38759 return resultobj;
38760 fail:
38761 {
38762 if (temp4)
38763 delete arg4;
38764 }
38765 {
38766 if (temp6)
38767 delete arg6;
38768 }
38769 return NULL;
38770 }
38771
38772
38773 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38774 PyObject *resultobj = 0;
38775 wxMenu *arg1 = (wxMenu *) 0 ;
38776 int arg2 ;
38777 wxString *arg3 = 0 ;
38778 wxString const &arg4_defvalue = wxPyEmptyString ;
38779 wxString *arg4 = (wxString *) &arg4_defvalue ;
38780 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38781 wxMenuItem *result = 0 ;
38782 void *argp1 = 0 ;
38783 int res1 = 0 ;
38784 int val2 ;
38785 int ecode2 = 0 ;
38786 bool temp3 = false ;
38787 bool temp4 = false ;
38788 int val5 ;
38789 int ecode5 = 0 ;
38790 PyObject * obj0 = 0 ;
38791 PyObject * obj1 = 0 ;
38792 PyObject * obj2 = 0 ;
38793 PyObject * obj3 = 0 ;
38794 PyObject * obj4 = 0 ;
38795 char * kwnames[] = {
38796 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38797 };
38798
38799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38803 }
38804 arg1 = reinterpret_cast< wxMenu * >(argp1);
38805 ecode2 = SWIG_AsVal_int(obj1, &val2);
38806 if (!SWIG_IsOK(ecode2)) {
38807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38808 }
38809 arg2 = static_cast< int >(val2);
38810 {
38811 arg3 = wxString_in_helper(obj2);
38812 if (arg3 == NULL) SWIG_fail;
38813 temp3 = true;
38814 }
38815 if (obj3) {
38816 {
38817 arg4 = wxString_in_helper(obj3);
38818 if (arg4 == NULL) SWIG_fail;
38819 temp4 = true;
38820 }
38821 }
38822 if (obj4) {
38823 ecode5 = SWIG_AsVal_int(obj4, &val5);
38824 if (!SWIG_IsOK(ecode5)) {
38825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38826 }
38827 arg5 = static_cast< wxItemKind >(val5);
38828 }
38829 {
38830 PyThreadState* __tstate = wxPyBeginAllowThreads();
38831 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38832 wxPyEndAllowThreads(__tstate);
38833 if (PyErr_Occurred()) SWIG_fail;
38834 }
38835 {
38836 resultobj = wxPyMake_wxObject(result, (bool)0);
38837 }
38838 {
38839 if (temp3)
38840 delete arg3;
38841 }
38842 {
38843 if (temp4)
38844 delete arg4;
38845 }
38846 return resultobj;
38847 fail:
38848 {
38849 if (temp3)
38850 delete arg3;
38851 }
38852 {
38853 if (temp4)
38854 delete arg4;
38855 }
38856 return NULL;
38857 }
38858
38859
38860 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38861 PyObject *resultobj = 0;
38862 wxMenu *arg1 = (wxMenu *) 0 ;
38863 wxMenuItem *result = 0 ;
38864 void *argp1 = 0 ;
38865 int res1 = 0 ;
38866 PyObject *swig_obj[1] ;
38867
38868 if (!args) SWIG_fail;
38869 swig_obj[0] = args;
38870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38871 if (!SWIG_IsOK(res1)) {
38872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38873 }
38874 arg1 = reinterpret_cast< wxMenu * >(argp1);
38875 {
38876 PyThreadState* __tstate = wxPyBeginAllowThreads();
38877 result = (wxMenuItem *)(arg1)->PrependSeparator();
38878 wxPyEndAllowThreads(__tstate);
38879 if (PyErr_Occurred()) SWIG_fail;
38880 }
38881 {
38882 resultobj = wxPyMake_wxObject(result, (bool)0);
38883 }
38884 return resultobj;
38885 fail:
38886 return NULL;
38887 }
38888
38889
38890 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38891 PyObject *resultobj = 0;
38892 wxMenu *arg1 = (wxMenu *) 0 ;
38893 int arg2 ;
38894 wxString *arg3 = 0 ;
38895 wxString const &arg4_defvalue = wxPyEmptyString ;
38896 wxString *arg4 = (wxString *) &arg4_defvalue ;
38897 wxMenuItem *result = 0 ;
38898 void *argp1 = 0 ;
38899 int res1 = 0 ;
38900 int val2 ;
38901 int ecode2 = 0 ;
38902 bool temp3 = false ;
38903 bool temp4 = false ;
38904 PyObject * obj0 = 0 ;
38905 PyObject * obj1 = 0 ;
38906 PyObject * obj2 = 0 ;
38907 PyObject * obj3 = 0 ;
38908 char * kwnames[] = {
38909 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38910 };
38911
38912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38914 if (!SWIG_IsOK(res1)) {
38915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38916 }
38917 arg1 = reinterpret_cast< wxMenu * >(argp1);
38918 ecode2 = SWIG_AsVal_int(obj1, &val2);
38919 if (!SWIG_IsOK(ecode2)) {
38920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
38921 }
38922 arg2 = static_cast< int >(val2);
38923 {
38924 arg3 = wxString_in_helper(obj2);
38925 if (arg3 == NULL) SWIG_fail;
38926 temp3 = true;
38927 }
38928 if (obj3) {
38929 {
38930 arg4 = wxString_in_helper(obj3);
38931 if (arg4 == NULL) SWIG_fail;
38932 temp4 = true;
38933 }
38934 }
38935 {
38936 PyThreadState* __tstate = wxPyBeginAllowThreads();
38937 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38938 wxPyEndAllowThreads(__tstate);
38939 if (PyErr_Occurred()) SWIG_fail;
38940 }
38941 {
38942 resultobj = wxPyMake_wxObject(result, (bool)0);
38943 }
38944 {
38945 if (temp3)
38946 delete arg3;
38947 }
38948 {
38949 if (temp4)
38950 delete arg4;
38951 }
38952 return resultobj;
38953 fail:
38954 {
38955 if (temp3)
38956 delete arg3;
38957 }
38958 {
38959 if (temp4)
38960 delete arg4;
38961 }
38962 return NULL;
38963 }
38964
38965
38966 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38967 PyObject *resultobj = 0;
38968 wxMenu *arg1 = (wxMenu *) 0 ;
38969 int arg2 ;
38970 wxString *arg3 = 0 ;
38971 wxString const &arg4_defvalue = wxPyEmptyString ;
38972 wxString *arg4 = (wxString *) &arg4_defvalue ;
38973 wxMenuItem *result = 0 ;
38974 void *argp1 = 0 ;
38975 int res1 = 0 ;
38976 int val2 ;
38977 int ecode2 = 0 ;
38978 bool temp3 = false ;
38979 bool temp4 = false ;
38980 PyObject * obj0 = 0 ;
38981 PyObject * obj1 = 0 ;
38982 PyObject * obj2 = 0 ;
38983 PyObject * obj3 = 0 ;
38984 char * kwnames[] = {
38985 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38986 };
38987
38988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38990 if (!SWIG_IsOK(res1)) {
38991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38992 }
38993 arg1 = reinterpret_cast< wxMenu * >(argp1);
38994 ecode2 = SWIG_AsVal_int(obj1, &val2);
38995 if (!SWIG_IsOK(ecode2)) {
38996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
38997 }
38998 arg2 = static_cast< int >(val2);
38999 {
39000 arg3 = wxString_in_helper(obj2);
39001 if (arg3 == NULL) SWIG_fail;
39002 temp3 = true;
39003 }
39004 if (obj3) {
39005 {
39006 arg4 = wxString_in_helper(obj3);
39007 if (arg4 == NULL) SWIG_fail;
39008 temp4 = true;
39009 }
39010 }
39011 {
39012 PyThreadState* __tstate = wxPyBeginAllowThreads();
39013 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39014 wxPyEndAllowThreads(__tstate);
39015 if (PyErr_Occurred()) SWIG_fail;
39016 }
39017 {
39018 resultobj = wxPyMake_wxObject(result, (bool)0);
39019 }
39020 {
39021 if (temp3)
39022 delete arg3;
39023 }
39024 {
39025 if (temp4)
39026 delete arg4;
39027 }
39028 return resultobj;
39029 fail:
39030 {
39031 if (temp3)
39032 delete arg3;
39033 }
39034 {
39035 if (temp4)
39036 delete arg4;
39037 }
39038 return NULL;
39039 }
39040
39041
39042 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39043 PyObject *resultobj = 0;
39044 wxMenu *arg1 = (wxMenu *) 0 ;
39045 int arg2 ;
39046 wxString *arg3 = 0 ;
39047 wxMenu *arg4 = (wxMenu *) 0 ;
39048 wxString const &arg5_defvalue = wxPyEmptyString ;
39049 wxString *arg5 = (wxString *) &arg5_defvalue ;
39050 wxMenuItem *result = 0 ;
39051 void *argp1 = 0 ;
39052 int res1 = 0 ;
39053 int val2 ;
39054 int ecode2 = 0 ;
39055 bool temp3 = false ;
39056 void *argp4 = 0 ;
39057 int res4 = 0 ;
39058 bool temp5 = false ;
39059 PyObject * obj0 = 0 ;
39060 PyObject * obj1 = 0 ;
39061 PyObject * obj2 = 0 ;
39062 PyObject * obj3 = 0 ;
39063 PyObject * obj4 = 0 ;
39064 char * kwnames[] = {
39065 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39066 };
39067
39068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39070 if (!SWIG_IsOK(res1)) {
39071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39072 }
39073 arg1 = reinterpret_cast< wxMenu * >(argp1);
39074 ecode2 = SWIG_AsVal_int(obj1, &val2);
39075 if (!SWIG_IsOK(ecode2)) {
39076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39077 }
39078 arg2 = static_cast< int >(val2);
39079 {
39080 arg3 = wxString_in_helper(obj2);
39081 if (arg3 == NULL) SWIG_fail;
39082 temp3 = true;
39083 }
39084 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39085 if (!SWIG_IsOK(res4)) {
39086 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39087 }
39088 arg4 = reinterpret_cast< wxMenu * >(argp4);
39089 if (obj4) {
39090 {
39091 arg5 = wxString_in_helper(obj4);
39092 if (arg5 == NULL) SWIG_fail;
39093 temp5 = true;
39094 }
39095 }
39096 {
39097 PyThreadState* __tstate = wxPyBeginAllowThreads();
39098 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39099 wxPyEndAllowThreads(__tstate);
39100 if (PyErr_Occurred()) SWIG_fail;
39101 }
39102 {
39103 resultobj = wxPyMake_wxObject(result, (bool)0);
39104 }
39105 {
39106 if (temp3)
39107 delete arg3;
39108 }
39109 {
39110 if (temp5)
39111 delete arg5;
39112 }
39113 return resultobj;
39114 fail:
39115 {
39116 if (temp3)
39117 delete arg3;
39118 }
39119 {
39120 if (temp5)
39121 delete arg5;
39122 }
39123 return NULL;
39124 }
39125
39126
39127 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39128 PyObject *resultobj = 0;
39129 wxMenu *arg1 = (wxMenu *) 0 ;
39130 int arg2 ;
39131 wxMenuItem *result = 0 ;
39132 void *argp1 = 0 ;
39133 int res1 = 0 ;
39134 int val2 ;
39135 int ecode2 = 0 ;
39136 PyObject * obj0 = 0 ;
39137 PyObject * obj1 = 0 ;
39138 char * kwnames[] = {
39139 (char *) "self",(char *) "id", NULL
39140 };
39141
39142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39144 if (!SWIG_IsOK(res1)) {
39145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39146 }
39147 arg1 = reinterpret_cast< wxMenu * >(argp1);
39148 ecode2 = SWIG_AsVal_int(obj1, &val2);
39149 if (!SWIG_IsOK(ecode2)) {
39150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39151 }
39152 arg2 = static_cast< int >(val2);
39153 {
39154 PyThreadState* __tstate = wxPyBeginAllowThreads();
39155 result = (wxMenuItem *)(arg1)->Remove(arg2);
39156 wxPyEndAllowThreads(__tstate);
39157 if (PyErr_Occurred()) SWIG_fail;
39158 }
39159 {
39160 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39161 }
39162 return resultobj;
39163 fail:
39164 return NULL;
39165 }
39166
39167
39168 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39169 PyObject *resultobj = 0;
39170 wxMenu *arg1 = (wxMenu *) 0 ;
39171 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39172 wxMenuItem *result = 0 ;
39173 void *argp1 = 0 ;
39174 int res1 = 0 ;
39175 void *argp2 = 0 ;
39176 int res2 = 0 ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 char * kwnames[] = {
39180 (char *) "self",(char *) "item", NULL
39181 };
39182
39183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39185 if (!SWIG_IsOK(res1)) {
39186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39187 }
39188 arg1 = reinterpret_cast< wxMenu * >(argp1);
39189 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39190 if (!SWIG_IsOK(res2)) {
39191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39192 }
39193 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39194 {
39195 PyThreadState* __tstate = wxPyBeginAllowThreads();
39196 result = (wxMenuItem *)(arg1)->Remove(arg2);
39197 wxPyEndAllowThreads(__tstate);
39198 if (PyErr_Occurred()) SWIG_fail;
39199 }
39200 {
39201 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39202 }
39203 return resultobj;
39204 fail:
39205 return NULL;
39206 }
39207
39208
39209 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39210 PyObject *resultobj = 0;
39211 wxMenu *arg1 = (wxMenu *) 0 ;
39212 int arg2 ;
39213 bool result;
39214 void *argp1 = 0 ;
39215 int res1 = 0 ;
39216 int val2 ;
39217 int ecode2 = 0 ;
39218 PyObject * obj0 = 0 ;
39219 PyObject * obj1 = 0 ;
39220 char * kwnames[] = {
39221 (char *) "self",(char *) "id", NULL
39222 };
39223
39224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39226 if (!SWIG_IsOK(res1)) {
39227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39228 }
39229 arg1 = reinterpret_cast< wxMenu * >(argp1);
39230 ecode2 = SWIG_AsVal_int(obj1, &val2);
39231 if (!SWIG_IsOK(ecode2)) {
39232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39233 }
39234 arg2 = static_cast< int >(val2);
39235 {
39236 PyThreadState* __tstate = wxPyBeginAllowThreads();
39237 result = (bool)(arg1)->Delete(arg2);
39238 wxPyEndAllowThreads(__tstate);
39239 if (PyErr_Occurred()) SWIG_fail;
39240 }
39241 {
39242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39243 }
39244 return resultobj;
39245 fail:
39246 return NULL;
39247 }
39248
39249
39250 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39251 PyObject *resultobj = 0;
39252 wxMenu *arg1 = (wxMenu *) 0 ;
39253 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39254 bool result;
39255 void *argp1 = 0 ;
39256 int res1 = 0 ;
39257 void *argp2 = 0 ;
39258 int res2 = 0 ;
39259 PyObject * obj0 = 0 ;
39260 PyObject * obj1 = 0 ;
39261 char * kwnames[] = {
39262 (char *) "self",(char *) "item", NULL
39263 };
39264
39265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39269 }
39270 arg1 = reinterpret_cast< wxMenu * >(argp1);
39271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39272 if (!SWIG_IsOK(res2)) {
39273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39274 }
39275 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39276 {
39277 PyThreadState* __tstate = wxPyBeginAllowThreads();
39278 result = (bool)(arg1)->Delete(arg2);
39279 wxPyEndAllowThreads(__tstate);
39280 if (PyErr_Occurred()) SWIG_fail;
39281 }
39282 {
39283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39284 }
39285 return resultobj;
39286 fail:
39287 return NULL;
39288 }
39289
39290
39291 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39292 PyObject *resultobj = 0;
39293 wxMenu *arg1 = (wxMenu *) 0 ;
39294 void *argp1 = 0 ;
39295 int res1 = 0 ;
39296 PyObject *swig_obj[1] ;
39297
39298 if (!args) SWIG_fail;
39299 swig_obj[0] = args;
39300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39301 if (!SWIG_IsOK(res1)) {
39302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39303 }
39304 arg1 = reinterpret_cast< wxMenu * >(argp1);
39305 {
39306 PyThreadState* __tstate = wxPyBeginAllowThreads();
39307 wxMenu_Destroy(arg1);
39308 wxPyEndAllowThreads(__tstate);
39309 if (PyErr_Occurred()) SWIG_fail;
39310 }
39311 resultobj = SWIG_Py_Void();
39312 return resultobj;
39313 fail:
39314 return NULL;
39315 }
39316
39317
39318 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39319 PyObject *resultobj = 0;
39320 wxMenu *arg1 = (wxMenu *) 0 ;
39321 int arg2 ;
39322 bool result;
39323 void *argp1 = 0 ;
39324 int res1 = 0 ;
39325 int val2 ;
39326 int ecode2 = 0 ;
39327 PyObject * obj0 = 0 ;
39328 PyObject * obj1 = 0 ;
39329 char * kwnames[] = {
39330 (char *) "self",(char *) "id", NULL
39331 };
39332
39333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39335 if (!SWIG_IsOK(res1)) {
39336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39337 }
39338 arg1 = reinterpret_cast< wxMenu * >(argp1);
39339 ecode2 = SWIG_AsVal_int(obj1, &val2);
39340 if (!SWIG_IsOK(ecode2)) {
39341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39342 }
39343 arg2 = static_cast< int >(val2);
39344 {
39345 PyThreadState* __tstate = wxPyBeginAllowThreads();
39346 result = (bool)(arg1)->Destroy(arg2);
39347 wxPyEndAllowThreads(__tstate);
39348 if (PyErr_Occurred()) SWIG_fail;
39349 }
39350 {
39351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39352 }
39353 return resultobj;
39354 fail:
39355 return NULL;
39356 }
39357
39358
39359 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39360 PyObject *resultobj = 0;
39361 wxMenu *arg1 = (wxMenu *) 0 ;
39362 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39363 bool result;
39364 void *argp1 = 0 ;
39365 int res1 = 0 ;
39366 void *argp2 = 0 ;
39367 int res2 = 0 ;
39368 PyObject * obj0 = 0 ;
39369 PyObject * obj1 = 0 ;
39370 char * kwnames[] = {
39371 (char *) "self",(char *) "item", NULL
39372 };
39373
39374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39376 if (!SWIG_IsOK(res1)) {
39377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39378 }
39379 arg1 = reinterpret_cast< wxMenu * >(argp1);
39380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39381 if (!SWIG_IsOK(res2)) {
39382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39383 }
39384 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39385 {
39386 PyThreadState* __tstate = wxPyBeginAllowThreads();
39387 result = (bool)(arg1)->Destroy(arg2);
39388 wxPyEndAllowThreads(__tstate);
39389 if (PyErr_Occurred()) SWIG_fail;
39390 }
39391 {
39392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39393 }
39394 return resultobj;
39395 fail:
39396 return NULL;
39397 }
39398
39399
39400 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39401 PyObject *resultobj = 0;
39402 wxMenu *arg1 = (wxMenu *) 0 ;
39403 size_t result;
39404 void *argp1 = 0 ;
39405 int res1 = 0 ;
39406 PyObject *swig_obj[1] ;
39407
39408 if (!args) SWIG_fail;
39409 swig_obj[0] = args;
39410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39411 if (!SWIG_IsOK(res1)) {
39412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39413 }
39414 arg1 = reinterpret_cast< wxMenu * >(argp1);
39415 {
39416 PyThreadState* __tstate = wxPyBeginAllowThreads();
39417 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39418 wxPyEndAllowThreads(__tstate);
39419 if (PyErr_Occurred()) SWIG_fail;
39420 }
39421 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39422 return resultobj;
39423 fail:
39424 return NULL;
39425 }
39426
39427
39428 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39429 PyObject *resultobj = 0;
39430 wxMenu *arg1 = (wxMenu *) 0 ;
39431 PyObject *result = 0 ;
39432 void *argp1 = 0 ;
39433 int res1 = 0 ;
39434 PyObject *swig_obj[1] ;
39435
39436 if (!args) SWIG_fail;
39437 swig_obj[0] = args;
39438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39439 if (!SWIG_IsOK(res1)) {
39440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39441 }
39442 arg1 = reinterpret_cast< wxMenu * >(argp1);
39443 {
39444 PyThreadState* __tstate = wxPyBeginAllowThreads();
39445 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39446 wxPyEndAllowThreads(__tstate);
39447 if (PyErr_Occurred()) SWIG_fail;
39448 }
39449 resultobj = result;
39450 return resultobj;
39451 fail:
39452 return NULL;
39453 }
39454
39455
39456 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj = 0;
39458 wxMenu *arg1 = (wxMenu *) 0 ;
39459 wxString *arg2 = 0 ;
39460 int result;
39461 void *argp1 = 0 ;
39462 int res1 = 0 ;
39463 bool temp2 = false ;
39464 PyObject * obj0 = 0 ;
39465 PyObject * obj1 = 0 ;
39466 char * kwnames[] = {
39467 (char *) "self",(char *) "item", NULL
39468 };
39469
39470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39472 if (!SWIG_IsOK(res1)) {
39473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39474 }
39475 arg1 = reinterpret_cast< wxMenu * >(argp1);
39476 {
39477 arg2 = wxString_in_helper(obj1);
39478 if (arg2 == NULL) SWIG_fail;
39479 temp2 = true;
39480 }
39481 {
39482 PyThreadState* __tstate = wxPyBeginAllowThreads();
39483 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39484 wxPyEndAllowThreads(__tstate);
39485 if (PyErr_Occurred()) SWIG_fail;
39486 }
39487 resultobj = SWIG_From_int(static_cast< int >(result));
39488 {
39489 if (temp2)
39490 delete arg2;
39491 }
39492 return resultobj;
39493 fail:
39494 {
39495 if (temp2)
39496 delete arg2;
39497 }
39498 return NULL;
39499 }
39500
39501
39502 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39503 PyObject *resultobj = 0;
39504 wxMenu *arg1 = (wxMenu *) 0 ;
39505 int arg2 ;
39506 wxMenuItem *result = 0 ;
39507 void *argp1 = 0 ;
39508 int res1 = 0 ;
39509 int val2 ;
39510 int ecode2 = 0 ;
39511 PyObject * obj0 = 0 ;
39512 PyObject * obj1 = 0 ;
39513 char * kwnames[] = {
39514 (char *) "self",(char *) "id", NULL
39515 };
39516
39517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39519 if (!SWIG_IsOK(res1)) {
39520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39521 }
39522 arg1 = reinterpret_cast< wxMenu * >(argp1);
39523 ecode2 = SWIG_AsVal_int(obj1, &val2);
39524 if (!SWIG_IsOK(ecode2)) {
39525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39526 }
39527 arg2 = static_cast< int >(val2);
39528 {
39529 PyThreadState* __tstate = wxPyBeginAllowThreads();
39530 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39531 wxPyEndAllowThreads(__tstate);
39532 if (PyErr_Occurred()) SWIG_fail;
39533 }
39534 {
39535 resultobj = wxPyMake_wxObject(result, (bool)0);
39536 }
39537 return resultobj;
39538 fail:
39539 return NULL;
39540 }
39541
39542
39543 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39544 PyObject *resultobj = 0;
39545 wxMenu *arg1 = (wxMenu *) 0 ;
39546 size_t arg2 ;
39547 wxMenuItem *result = 0 ;
39548 void *argp1 = 0 ;
39549 int res1 = 0 ;
39550 size_t val2 ;
39551 int ecode2 = 0 ;
39552 PyObject * obj0 = 0 ;
39553 PyObject * obj1 = 0 ;
39554 char * kwnames[] = {
39555 (char *) "self",(char *) "position", NULL
39556 };
39557
39558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39560 if (!SWIG_IsOK(res1)) {
39561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39562 }
39563 arg1 = reinterpret_cast< wxMenu * >(argp1);
39564 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39565 if (!SWIG_IsOK(ecode2)) {
39566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39567 }
39568 arg2 = static_cast< size_t >(val2);
39569 {
39570 PyThreadState* __tstate = wxPyBeginAllowThreads();
39571 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39572 wxPyEndAllowThreads(__tstate);
39573 if (PyErr_Occurred()) SWIG_fail;
39574 }
39575 {
39576 resultobj = wxPyMake_wxObject(result, (bool)0);
39577 }
39578 return resultobj;
39579 fail:
39580 return NULL;
39581 }
39582
39583
39584 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39585 PyObject *resultobj = 0;
39586 wxMenu *arg1 = (wxMenu *) 0 ;
39587 int arg2 ;
39588 bool arg3 ;
39589 void *argp1 = 0 ;
39590 int res1 = 0 ;
39591 int val2 ;
39592 int ecode2 = 0 ;
39593 bool val3 ;
39594 int ecode3 = 0 ;
39595 PyObject * obj0 = 0 ;
39596 PyObject * obj1 = 0 ;
39597 PyObject * obj2 = 0 ;
39598 char * kwnames[] = {
39599 (char *) "self",(char *) "id",(char *) "enable", NULL
39600 };
39601
39602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39604 if (!SWIG_IsOK(res1)) {
39605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39606 }
39607 arg1 = reinterpret_cast< wxMenu * >(argp1);
39608 ecode2 = SWIG_AsVal_int(obj1, &val2);
39609 if (!SWIG_IsOK(ecode2)) {
39610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39611 }
39612 arg2 = static_cast< int >(val2);
39613 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39614 if (!SWIG_IsOK(ecode3)) {
39615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39616 }
39617 arg3 = static_cast< bool >(val3);
39618 {
39619 PyThreadState* __tstate = wxPyBeginAllowThreads();
39620 (arg1)->Enable(arg2,arg3);
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 resultobj = SWIG_Py_Void();
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj = 0;
39633 wxMenu *arg1 = (wxMenu *) 0 ;
39634 int arg2 ;
39635 bool result;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 int val2 ;
39639 int ecode2 = 0 ;
39640 PyObject * obj0 = 0 ;
39641 PyObject * obj1 = 0 ;
39642 char * kwnames[] = {
39643 (char *) "self",(char *) "id", NULL
39644 };
39645
39646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39648 if (!SWIG_IsOK(res1)) {
39649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39650 }
39651 arg1 = reinterpret_cast< wxMenu * >(argp1);
39652 ecode2 = SWIG_AsVal_int(obj1, &val2);
39653 if (!SWIG_IsOK(ecode2)) {
39654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39655 }
39656 arg2 = static_cast< int >(val2);
39657 {
39658 PyThreadState* __tstate = wxPyBeginAllowThreads();
39659 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39660 wxPyEndAllowThreads(__tstate);
39661 if (PyErr_Occurred()) SWIG_fail;
39662 }
39663 {
39664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39665 }
39666 return resultobj;
39667 fail:
39668 return NULL;
39669 }
39670
39671
39672 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39673 PyObject *resultobj = 0;
39674 wxMenu *arg1 = (wxMenu *) 0 ;
39675 int arg2 ;
39676 bool arg3 ;
39677 void *argp1 = 0 ;
39678 int res1 = 0 ;
39679 int val2 ;
39680 int ecode2 = 0 ;
39681 bool val3 ;
39682 int ecode3 = 0 ;
39683 PyObject * obj0 = 0 ;
39684 PyObject * obj1 = 0 ;
39685 PyObject * obj2 = 0 ;
39686 char * kwnames[] = {
39687 (char *) "self",(char *) "id",(char *) "check", NULL
39688 };
39689
39690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39692 if (!SWIG_IsOK(res1)) {
39693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39694 }
39695 arg1 = reinterpret_cast< wxMenu * >(argp1);
39696 ecode2 = SWIG_AsVal_int(obj1, &val2);
39697 if (!SWIG_IsOK(ecode2)) {
39698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39699 }
39700 arg2 = static_cast< int >(val2);
39701 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39702 if (!SWIG_IsOK(ecode3)) {
39703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39704 }
39705 arg3 = static_cast< bool >(val3);
39706 {
39707 PyThreadState* __tstate = wxPyBeginAllowThreads();
39708 (arg1)->Check(arg2,arg3);
39709 wxPyEndAllowThreads(__tstate);
39710 if (PyErr_Occurred()) SWIG_fail;
39711 }
39712 resultobj = SWIG_Py_Void();
39713 return resultobj;
39714 fail:
39715 return NULL;
39716 }
39717
39718
39719 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39720 PyObject *resultobj = 0;
39721 wxMenu *arg1 = (wxMenu *) 0 ;
39722 int arg2 ;
39723 bool result;
39724 void *argp1 = 0 ;
39725 int res1 = 0 ;
39726 int val2 ;
39727 int ecode2 = 0 ;
39728 PyObject * obj0 = 0 ;
39729 PyObject * obj1 = 0 ;
39730 char * kwnames[] = {
39731 (char *) "self",(char *) "id", NULL
39732 };
39733
39734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39736 if (!SWIG_IsOK(res1)) {
39737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39738 }
39739 arg1 = reinterpret_cast< wxMenu * >(argp1);
39740 ecode2 = SWIG_AsVal_int(obj1, &val2);
39741 if (!SWIG_IsOK(ecode2)) {
39742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39743 }
39744 arg2 = static_cast< int >(val2);
39745 {
39746 PyThreadState* __tstate = wxPyBeginAllowThreads();
39747 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39748 wxPyEndAllowThreads(__tstate);
39749 if (PyErr_Occurred()) SWIG_fail;
39750 }
39751 {
39752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39753 }
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39761 PyObject *resultobj = 0;
39762 wxMenu *arg1 = (wxMenu *) 0 ;
39763 int arg2 ;
39764 wxString *arg3 = 0 ;
39765 void *argp1 = 0 ;
39766 int res1 = 0 ;
39767 int val2 ;
39768 int ecode2 = 0 ;
39769 bool temp3 = false ;
39770 PyObject * obj0 = 0 ;
39771 PyObject * obj1 = 0 ;
39772 PyObject * obj2 = 0 ;
39773 char * kwnames[] = {
39774 (char *) "self",(char *) "id",(char *) "label", NULL
39775 };
39776
39777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39779 if (!SWIG_IsOK(res1)) {
39780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39781 }
39782 arg1 = reinterpret_cast< wxMenu * >(argp1);
39783 ecode2 = SWIG_AsVal_int(obj1, &val2);
39784 if (!SWIG_IsOK(ecode2)) {
39785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39786 }
39787 arg2 = static_cast< int >(val2);
39788 {
39789 arg3 = wxString_in_helper(obj2);
39790 if (arg3 == NULL) SWIG_fail;
39791 temp3 = true;
39792 }
39793 {
39794 PyThreadState* __tstate = wxPyBeginAllowThreads();
39795 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39796 wxPyEndAllowThreads(__tstate);
39797 if (PyErr_Occurred()) SWIG_fail;
39798 }
39799 resultobj = SWIG_Py_Void();
39800 {
39801 if (temp3)
39802 delete arg3;
39803 }
39804 return resultobj;
39805 fail:
39806 {
39807 if (temp3)
39808 delete arg3;
39809 }
39810 return NULL;
39811 }
39812
39813
39814 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39815 PyObject *resultobj = 0;
39816 wxMenu *arg1 = (wxMenu *) 0 ;
39817 int arg2 ;
39818 wxString result;
39819 void *argp1 = 0 ;
39820 int res1 = 0 ;
39821 int val2 ;
39822 int ecode2 = 0 ;
39823 PyObject * obj0 = 0 ;
39824 PyObject * obj1 = 0 ;
39825 char * kwnames[] = {
39826 (char *) "self",(char *) "id", NULL
39827 };
39828
39829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39831 if (!SWIG_IsOK(res1)) {
39832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39833 }
39834 arg1 = reinterpret_cast< wxMenu * >(argp1);
39835 ecode2 = SWIG_AsVal_int(obj1, &val2);
39836 if (!SWIG_IsOK(ecode2)) {
39837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39838 }
39839 arg2 = static_cast< int >(val2);
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 {
39847 #if wxUSE_UNICODE
39848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39849 #else
39850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39851 #endif
39852 }
39853 return resultobj;
39854 fail:
39855 return NULL;
39856 }
39857
39858
39859 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj = 0;
39861 wxMenu *arg1 = (wxMenu *) 0 ;
39862 int arg2 ;
39863 wxString *arg3 = 0 ;
39864 void *argp1 = 0 ;
39865 int res1 = 0 ;
39866 int val2 ;
39867 int ecode2 = 0 ;
39868 bool temp3 = false ;
39869 PyObject * obj0 = 0 ;
39870 PyObject * obj1 = 0 ;
39871 PyObject * obj2 = 0 ;
39872 char * kwnames[] = {
39873 (char *) "self",(char *) "id",(char *) "helpString", NULL
39874 };
39875
39876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39878 if (!SWIG_IsOK(res1)) {
39879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
39880 }
39881 arg1 = reinterpret_cast< wxMenu * >(argp1);
39882 ecode2 = SWIG_AsVal_int(obj1, &val2);
39883 if (!SWIG_IsOK(ecode2)) {
39884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
39885 }
39886 arg2 = static_cast< int >(val2);
39887 {
39888 arg3 = wxString_in_helper(obj2);
39889 if (arg3 == NULL) SWIG_fail;
39890 temp3 = true;
39891 }
39892 {
39893 PyThreadState* __tstate = wxPyBeginAllowThreads();
39894 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
39895 wxPyEndAllowThreads(__tstate);
39896 if (PyErr_Occurred()) SWIG_fail;
39897 }
39898 resultobj = SWIG_Py_Void();
39899 {
39900 if (temp3)
39901 delete arg3;
39902 }
39903 return resultobj;
39904 fail:
39905 {
39906 if (temp3)
39907 delete arg3;
39908 }
39909 return NULL;
39910 }
39911
39912
39913 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj = 0;
39915 wxMenu *arg1 = (wxMenu *) 0 ;
39916 int arg2 ;
39917 wxString result;
39918 void *argp1 = 0 ;
39919 int res1 = 0 ;
39920 int val2 ;
39921 int ecode2 = 0 ;
39922 PyObject * obj0 = 0 ;
39923 PyObject * obj1 = 0 ;
39924 char * kwnames[] = {
39925 (char *) "self",(char *) "id", NULL
39926 };
39927
39928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
39929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39930 if (!SWIG_IsOK(res1)) {
39931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
39932 }
39933 arg1 = reinterpret_cast< wxMenu * >(argp1);
39934 ecode2 = SWIG_AsVal_int(obj1, &val2);
39935 if (!SWIG_IsOK(ecode2)) {
39936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
39937 }
39938 arg2 = static_cast< int >(val2);
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 {
39946 #if wxUSE_UNICODE
39947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39948 #else
39949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39950 #endif
39951 }
39952 return resultobj;
39953 fail:
39954 return NULL;
39955 }
39956
39957
39958 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39959 PyObject *resultobj = 0;
39960 wxMenu *arg1 = (wxMenu *) 0 ;
39961 wxString *arg2 = 0 ;
39962 void *argp1 = 0 ;
39963 int res1 = 0 ;
39964 bool temp2 = false ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 char * kwnames[] = {
39968 (char *) "self",(char *) "title", NULL
39969 };
39970
39971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
39972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39973 if (!SWIG_IsOK(res1)) {
39974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
39975 }
39976 arg1 = reinterpret_cast< wxMenu * >(argp1);
39977 {
39978 arg2 = wxString_in_helper(obj1);
39979 if (arg2 == NULL) SWIG_fail;
39980 temp2 = true;
39981 }
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 (arg1)->SetTitle((wxString const &)*arg2);
39985 wxPyEndAllowThreads(__tstate);
39986 if (PyErr_Occurred()) SWIG_fail;
39987 }
39988 resultobj = SWIG_Py_Void();
39989 {
39990 if (temp2)
39991 delete arg2;
39992 }
39993 return resultobj;
39994 fail:
39995 {
39996 if (temp2)
39997 delete arg2;
39998 }
39999 return NULL;
40000 }
40001
40002
40003 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40004 PyObject *resultobj = 0;
40005 wxMenu *arg1 = (wxMenu *) 0 ;
40006 wxString result;
40007 void *argp1 = 0 ;
40008 int res1 = 0 ;
40009 PyObject *swig_obj[1] ;
40010
40011 if (!args) SWIG_fail;
40012 swig_obj[0] = args;
40013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40014 if (!SWIG_IsOK(res1)) {
40015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40016 }
40017 arg1 = reinterpret_cast< wxMenu * >(argp1);
40018 {
40019 PyThreadState* __tstate = wxPyBeginAllowThreads();
40020 result = ((wxMenu const *)arg1)->GetTitle();
40021 wxPyEndAllowThreads(__tstate);
40022 if (PyErr_Occurred()) SWIG_fail;
40023 }
40024 {
40025 #if wxUSE_UNICODE
40026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40027 #else
40028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40029 #endif
40030 }
40031 return resultobj;
40032 fail:
40033 return NULL;
40034 }
40035
40036
40037 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40038 PyObject *resultobj = 0;
40039 wxMenu *arg1 = (wxMenu *) 0 ;
40040 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40041 void *argp1 = 0 ;
40042 int res1 = 0 ;
40043 void *argp2 = 0 ;
40044 int res2 = 0 ;
40045 PyObject * obj0 = 0 ;
40046 PyObject * obj1 = 0 ;
40047 char * kwnames[] = {
40048 (char *) "self",(char *) "handler", NULL
40049 };
40050
40051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40053 if (!SWIG_IsOK(res1)) {
40054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40055 }
40056 arg1 = reinterpret_cast< wxMenu * >(argp1);
40057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40058 if (!SWIG_IsOK(res2)) {
40059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40060 }
40061 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40062 {
40063 PyThreadState* __tstate = wxPyBeginAllowThreads();
40064 (arg1)->SetEventHandler(arg2);
40065 wxPyEndAllowThreads(__tstate);
40066 if (PyErr_Occurred()) SWIG_fail;
40067 }
40068 resultobj = SWIG_Py_Void();
40069 return resultobj;
40070 fail:
40071 return NULL;
40072 }
40073
40074
40075 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40076 PyObject *resultobj = 0;
40077 wxMenu *arg1 = (wxMenu *) 0 ;
40078 wxEvtHandler *result = 0 ;
40079 void *argp1 = 0 ;
40080 int res1 = 0 ;
40081 PyObject *swig_obj[1] ;
40082
40083 if (!args) SWIG_fail;
40084 swig_obj[0] = args;
40085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40086 if (!SWIG_IsOK(res1)) {
40087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40088 }
40089 arg1 = reinterpret_cast< wxMenu * >(argp1);
40090 {
40091 PyThreadState* __tstate = wxPyBeginAllowThreads();
40092 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40093 wxPyEndAllowThreads(__tstate);
40094 if (PyErr_Occurred()) SWIG_fail;
40095 }
40096 {
40097 resultobj = wxPyMake_wxObject(result, 0);
40098 }
40099 return resultobj;
40100 fail:
40101 return NULL;
40102 }
40103
40104
40105 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40106 PyObject *resultobj = 0;
40107 wxMenu *arg1 = (wxMenu *) 0 ;
40108 wxWindow *arg2 = (wxWindow *) 0 ;
40109 void *argp1 = 0 ;
40110 int res1 = 0 ;
40111 void *argp2 = 0 ;
40112 int res2 = 0 ;
40113 PyObject * obj0 = 0 ;
40114 PyObject * obj1 = 0 ;
40115 char * kwnames[] = {
40116 (char *) "self",(char *) "win", NULL
40117 };
40118
40119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40121 if (!SWIG_IsOK(res1)) {
40122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40123 }
40124 arg1 = reinterpret_cast< wxMenu * >(argp1);
40125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40126 if (!SWIG_IsOK(res2)) {
40127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40128 }
40129 arg2 = reinterpret_cast< wxWindow * >(argp2);
40130 {
40131 PyThreadState* __tstate = wxPyBeginAllowThreads();
40132 (arg1)->SetInvokingWindow(arg2);
40133 wxPyEndAllowThreads(__tstate);
40134 if (PyErr_Occurred()) SWIG_fail;
40135 }
40136 resultobj = SWIG_Py_Void();
40137 return resultobj;
40138 fail:
40139 return NULL;
40140 }
40141
40142
40143 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40144 PyObject *resultobj = 0;
40145 wxMenu *arg1 = (wxMenu *) 0 ;
40146 wxWindow *result = 0 ;
40147 void *argp1 = 0 ;
40148 int res1 = 0 ;
40149 PyObject *swig_obj[1] ;
40150
40151 if (!args) SWIG_fail;
40152 swig_obj[0] = args;
40153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40154 if (!SWIG_IsOK(res1)) {
40155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40156 }
40157 arg1 = reinterpret_cast< wxMenu * >(argp1);
40158 {
40159 PyThreadState* __tstate = wxPyBeginAllowThreads();
40160 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40161 wxPyEndAllowThreads(__tstate);
40162 if (PyErr_Occurred()) SWIG_fail;
40163 }
40164 {
40165 resultobj = wxPyMake_wxObject(result, 0);
40166 }
40167 return resultobj;
40168 fail:
40169 return NULL;
40170 }
40171
40172
40173 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40174 PyObject *resultobj = 0;
40175 wxMenu *arg1 = (wxMenu *) 0 ;
40176 long result;
40177 void *argp1 = 0 ;
40178 int res1 = 0 ;
40179 PyObject *swig_obj[1] ;
40180
40181 if (!args) SWIG_fail;
40182 swig_obj[0] = args;
40183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40184 if (!SWIG_IsOK(res1)) {
40185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40186 }
40187 arg1 = reinterpret_cast< wxMenu * >(argp1);
40188 {
40189 PyThreadState* __tstate = wxPyBeginAllowThreads();
40190 result = (long)((wxMenu const *)arg1)->GetStyle();
40191 wxPyEndAllowThreads(__tstate);
40192 if (PyErr_Occurred()) SWIG_fail;
40193 }
40194 resultobj = SWIG_From_long(static_cast< long >(result));
40195 return resultobj;
40196 fail:
40197 return NULL;
40198 }
40199
40200
40201 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40202 PyObject *resultobj = 0;
40203 wxMenu *arg1 = (wxMenu *) 0 ;
40204 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40205 void *argp1 = 0 ;
40206 int res1 = 0 ;
40207 void *argp2 = 0 ;
40208 int res2 = 0 ;
40209 PyObject * obj0 = 0 ;
40210 PyObject * obj1 = 0 ;
40211 char * kwnames[] = {
40212 (char *) "self",(char *) "source", NULL
40213 };
40214
40215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40217 if (!SWIG_IsOK(res1)) {
40218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40219 }
40220 arg1 = reinterpret_cast< wxMenu * >(argp1);
40221 if (obj1) {
40222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40223 if (!SWIG_IsOK(res2)) {
40224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40225 }
40226 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40227 }
40228 {
40229 PyThreadState* __tstate = wxPyBeginAllowThreads();
40230 (arg1)->UpdateUI(arg2);
40231 wxPyEndAllowThreads(__tstate);
40232 if (PyErr_Occurred()) SWIG_fail;
40233 }
40234 resultobj = SWIG_Py_Void();
40235 return resultobj;
40236 fail:
40237 return NULL;
40238 }
40239
40240
40241 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40242 PyObject *resultobj = 0;
40243 wxMenu *arg1 = (wxMenu *) 0 ;
40244 wxMenuBar *result = 0 ;
40245 void *argp1 = 0 ;
40246 int res1 = 0 ;
40247 PyObject *swig_obj[1] ;
40248
40249 if (!args) SWIG_fail;
40250 swig_obj[0] = args;
40251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40252 if (!SWIG_IsOK(res1)) {
40253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40254 }
40255 arg1 = reinterpret_cast< wxMenu * >(argp1);
40256 {
40257 PyThreadState* __tstate = wxPyBeginAllowThreads();
40258 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40259 wxPyEndAllowThreads(__tstate);
40260 if (PyErr_Occurred()) SWIG_fail;
40261 }
40262 {
40263 resultobj = wxPyMake_wxObject(result, (bool)0);
40264 }
40265 return resultobj;
40266 fail:
40267 return NULL;
40268 }
40269
40270
40271 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40272 PyObject *resultobj = 0;
40273 wxMenu *arg1 = (wxMenu *) 0 ;
40274 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40275 void *argp1 = 0 ;
40276 int res1 = 0 ;
40277 void *argp2 = 0 ;
40278 int res2 = 0 ;
40279 PyObject * obj0 = 0 ;
40280 PyObject * obj1 = 0 ;
40281 char * kwnames[] = {
40282 (char *) "self",(char *) "menubar", NULL
40283 };
40284
40285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40287 if (!SWIG_IsOK(res1)) {
40288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40289 }
40290 arg1 = reinterpret_cast< wxMenu * >(argp1);
40291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40292 if (!SWIG_IsOK(res2)) {
40293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40294 }
40295 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40296 {
40297 PyThreadState* __tstate = wxPyBeginAllowThreads();
40298 (arg1)->Attach(arg2);
40299 wxPyEndAllowThreads(__tstate);
40300 if (PyErr_Occurred()) SWIG_fail;
40301 }
40302 resultobj = SWIG_Py_Void();
40303 return resultobj;
40304 fail:
40305 return NULL;
40306 }
40307
40308
40309 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40310 PyObject *resultobj = 0;
40311 wxMenu *arg1 = (wxMenu *) 0 ;
40312 void *argp1 = 0 ;
40313 int res1 = 0 ;
40314 PyObject *swig_obj[1] ;
40315
40316 if (!args) SWIG_fail;
40317 swig_obj[0] = args;
40318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40319 if (!SWIG_IsOK(res1)) {
40320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40321 }
40322 arg1 = reinterpret_cast< wxMenu * >(argp1);
40323 {
40324 PyThreadState* __tstate = wxPyBeginAllowThreads();
40325 (arg1)->Detach();
40326 wxPyEndAllowThreads(__tstate);
40327 if (PyErr_Occurred()) SWIG_fail;
40328 }
40329 resultobj = SWIG_Py_Void();
40330 return resultobj;
40331 fail:
40332 return NULL;
40333 }
40334
40335
40336 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40337 PyObject *resultobj = 0;
40338 wxMenu *arg1 = (wxMenu *) 0 ;
40339 bool result;
40340 void *argp1 = 0 ;
40341 int res1 = 0 ;
40342 PyObject *swig_obj[1] ;
40343
40344 if (!args) SWIG_fail;
40345 swig_obj[0] = args;
40346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40347 if (!SWIG_IsOK(res1)) {
40348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40349 }
40350 arg1 = reinterpret_cast< wxMenu * >(argp1);
40351 {
40352 PyThreadState* __tstate = wxPyBeginAllowThreads();
40353 result = (bool)((wxMenu const *)arg1)->IsAttached();
40354 wxPyEndAllowThreads(__tstate);
40355 if (PyErr_Occurred()) SWIG_fail;
40356 }
40357 {
40358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40359 }
40360 return resultobj;
40361 fail:
40362 return NULL;
40363 }
40364
40365
40366 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40367 PyObject *resultobj = 0;
40368 wxMenu *arg1 = (wxMenu *) 0 ;
40369 wxMenu *arg2 = (wxMenu *) 0 ;
40370 void *argp1 = 0 ;
40371 int res1 = 0 ;
40372 void *argp2 = 0 ;
40373 int res2 = 0 ;
40374 PyObject * obj0 = 0 ;
40375 PyObject * obj1 = 0 ;
40376 char * kwnames[] = {
40377 (char *) "self",(char *) "parent", NULL
40378 };
40379
40380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40382 if (!SWIG_IsOK(res1)) {
40383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40384 }
40385 arg1 = reinterpret_cast< wxMenu * >(argp1);
40386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40387 if (!SWIG_IsOK(res2)) {
40388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40389 }
40390 arg2 = reinterpret_cast< wxMenu * >(argp2);
40391 {
40392 PyThreadState* __tstate = wxPyBeginAllowThreads();
40393 (arg1)->SetParent(arg2);
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 resultobj = SWIG_Py_Void();
40398 return resultobj;
40399 fail:
40400 return NULL;
40401 }
40402
40403
40404 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40405 PyObject *resultobj = 0;
40406 wxMenu *arg1 = (wxMenu *) 0 ;
40407 wxMenu *result = 0 ;
40408 void *argp1 = 0 ;
40409 int res1 = 0 ;
40410 PyObject *swig_obj[1] ;
40411
40412 if (!args) SWIG_fail;
40413 swig_obj[0] = args;
40414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40415 if (!SWIG_IsOK(res1)) {
40416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40417 }
40418 arg1 = reinterpret_cast< wxMenu * >(argp1);
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 resultobj = wxPyMake_wxObject(result, 0);
40427 }
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40435 PyObject *obj;
40436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40437 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40438 return SWIG_Py_Void();
40439 }
40440
40441 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40442 return SWIG_Python_InitShadowInstance(args);
40443 }
40444
40445 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40446 PyObject *resultobj = 0;
40447 long arg1 = (long) 0 ;
40448 wxMenuBar *result = 0 ;
40449 long val1 ;
40450 int ecode1 = 0 ;
40451 PyObject * obj0 = 0 ;
40452 char * kwnames[] = {
40453 (char *) "style", NULL
40454 };
40455
40456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40457 if (obj0) {
40458 ecode1 = SWIG_AsVal_long(obj0, &val1);
40459 if (!SWIG_IsOK(ecode1)) {
40460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40461 }
40462 arg1 = static_cast< long >(val1);
40463 }
40464 {
40465 if (!wxPyCheckForApp()) SWIG_fail;
40466 PyThreadState* __tstate = wxPyBeginAllowThreads();
40467 result = (wxMenuBar *)new wxMenuBar(arg1);
40468 wxPyEndAllowThreads(__tstate);
40469 if (PyErr_Occurred()) SWIG_fail;
40470 }
40471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40472 return resultobj;
40473 fail:
40474 return NULL;
40475 }
40476
40477
40478 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40479 PyObject *resultobj = 0;
40480 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40481 wxMenu *arg2 = (wxMenu *) 0 ;
40482 wxString *arg3 = 0 ;
40483 bool result;
40484 void *argp1 = 0 ;
40485 int res1 = 0 ;
40486 void *argp2 = 0 ;
40487 int res2 = 0 ;
40488 bool temp3 = false ;
40489 PyObject * obj0 = 0 ;
40490 PyObject * obj1 = 0 ;
40491 PyObject * obj2 = 0 ;
40492 char * kwnames[] = {
40493 (char *) "self",(char *) "menu",(char *) "title", NULL
40494 };
40495
40496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40498 if (!SWIG_IsOK(res1)) {
40499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40500 }
40501 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40503 if (!SWIG_IsOK(res2)) {
40504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40505 }
40506 arg2 = reinterpret_cast< wxMenu * >(argp2);
40507 {
40508 arg3 = wxString_in_helper(obj2);
40509 if (arg3 == NULL) SWIG_fail;
40510 temp3 = true;
40511 }
40512 {
40513 PyThreadState* __tstate = wxPyBeginAllowThreads();
40514 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40515 wxPyEndAllowThreads(__tstate);
40516 if (PyErr_Occurred()) SWIG_fail;
40517 }
40518 {
40519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40520 }
40521 {
40522 if (temp3)
40523 delete arg3;
40524 }
40525 return resultobj;
40526 fail:
40527 {
40528 if (temp3)
40529 delete arg3;
40530 }
40531 return NULL;
40532 }
40533
40534
40535 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40536 PyObject *resultobj = 0;
40537 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40538 size_t arg2 ;
40539 wxMenu *arg3 = (wxMenu *) 0 ;
40540 wxString *arg4 = 0 ;
40541 bool result;
40542 void *argp1 = 0 ;
40543 int res1 = 0 ;
40544 size_t val2 ;
40545 int ecode2 = 0 ;
40546 void *argp3 = 0 ;
40547 int res3 = 0 ;
40548 bool temp4 = false ;
40549 PyObject * obj0 = 0 ;
40550 PyObject * obj1 = 0 ;
40551 PyObject * obj2 = 0 ;
40552 PyObject * obj3 = 0 ;
40553 char * kwnames[] = {
40554 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40555 };
40556
40557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40559 if (!SWIG_IsOK(res1)) {
40560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40561 }
40562 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40563 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40564 if (!SWIG_IsOK(ecode2)) {
40565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40566 }
40567 arg2 = static_cast< size_t >(val2);
40568 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40569 if (!SWIG_IsOK(res3)) {
40570 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40571 }
40572 arg3 = reinterpret_cast< wxMenu * >(argp3);
40573 {
40574 arg4 = wxString_in_helper(obj3);
40575 if (arg4 == NULL) SWIG_fail;
40576 temp4 = true;
40577 }
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 {
40585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40586 }
40587 {
40588 if (temp4)
40589 delete arg4;
40590 }
40591 return resultobj;
40592 fail:
40593 {
40594 if (temp4)
40595 delete arg4;
40596 }
40597 return NULL;
40598 }
40599
40600
40601 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40602 PyObject *resultobj = 0;
40603 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40604 size_t result;
40605 void *argp1 = 0 ;
40606 int res1 = 0 ;
40607 PyObject *swig_obj[1] ;
40608
40609 if (!args) SWIG_fail;
40610 swig_obj[0] = args;
40611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40612 if (!SWIG_IsOK(res1)) {
40613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40614 }
40615 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40630 PyObject *resultobj = 0;
40631 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40632 size_t arg2 ;
40633 wxMenu *result = 0 ;
40634 void *argp1 = 0 ;
40635 int res1 = 0 ;
40636 size_t val2 ;
40637 int ecode2 = 0 ;
40638 PyObject * obj0 = 0 ;
40639 PyObject * obj1 = 0 ;
40640 char * kwnames[] = {
40641 (char *) "self",(char *) "pos", NULL
40642 };
40643
40644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40646 if (!SWIG_IsOK(res1)) {
40647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40648 }
40649 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40650 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40651 if (!SWIG_IsOK(ecode2)) {
40652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40653 }
40654 arg2 = static_cast< size_t >(val2);
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 {
40662 resultobj = wxPyMake_wxObject(result, 0);
40663 }
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj = 0;
40672 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40673 size_t arg2 ;
40674 wxMenu *arg3 = (wxMenu *) 0 ;
40675 wxString *arg4 = 0 ;
40676 wxMenu *result = 0 ;
40677 void *argp1 = 0 ;
40678 int res1 = 0 ;
40679 size_t val2 ;
40680 int ecode2 = 0 ;
40681 void *argp3 = 0 ;
40682 int res3 = 0 ;
40683 bool temp4 = false ;
40684 PyObject * obj0 = 0 ;
40685 PyObject * obj1 = 0 ;
40686 PyObject * obj2 = 0 ;
40687 PyObject * obj3 = 0 ;
40688 char * kwnames[] = {
40689 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40690 };
40691
40692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40694 if (!SWIG_IsOK(res1)) {
40695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40696 }
40697 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40698 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40699 if (!SWIG_IsOK(ecode2)) {
40700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40701 }
40702 arg2 = static_cast< size_t >(val2);
40703 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40704 if (!SWIG_IsOK(res3)) {
40705 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40706 }
40707 arg3 = reinterpret_cast< wxMenu * >(argp3);
40708 {
40709 arg4 = wxString_in_helper(obj3);
40710 if (arg4 == NULL) SWIG_fail;
40711 temp4 = true;
40712 }
40713 {
40714 PyThreadState* __tstate = wxPyBeginAllowThreads();
40715 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40716 wxPyEndAllowThreads(__tstate);
40717 if (PyErr_Occurred()) SWIG_fail;
40718 }
40719 {
40720 resultobj = wxPyMake_wxObject(result, 0);
40721 }
40722 {
40723 if (temp4)
40724 delete arg4;
40725 }
40726 return resultobj;
40727 fail:
40728 {
40729 if (temp4)
40730 delete arg4;
40731 }
40732 return NULL;
40733 }
40734
40735
40736 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40737 PyObject *resultobj = 0;
40738 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40739 size_t arg2 ;
40740 wxMenu *result = 0 ;
40741 void *argp1 = 0 ;
40742 int res1 = 0 ;
40743 size_t val2 ;
40744 int ecode2 = 0 ;
40745 PyObject * obj0 = 0 ;
40746 PyObject * obj1 = 0 ;
40747 char * kwnames[] = {
40748 (char *) "self",(char *) "pos", NULL
40749 };
40750
40751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40753 if (!SWIG_IsOK(res1)) {
40754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40755 }
40756 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40757 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40758 if (!SWIG_IsOK(ecode2)) {
40759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40760 }
40761 arg2 = static_cast< size_t >(val2);
40762 {
40763 PyThreadState* __tstate = wxPyBeginAllowThreads();
40764 result = (wxMenu *)(arg1)->Remove(arg2);
40765 wxPyEndAllowThreads(__tstate);
40766 if (PyErr_Occurred()) SWIG_fail;
40767 }
40768 {
40769 resultobj = wxPyMake_wxObject(result, 0);
40770 }
40771 return resultobj;
40772 fail:
40773 return NULL;
40774 }
40775
40776
40777 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40778 PyObject *resultobj = 0;
40779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40780 size_t arg2 ;
40781 bool arg3 ;
40782 void *argp1 = 0 ;
40783 int res1 = 0 ;
40784 size_t val2 ;
40785 int ecode2 = 0 ;
40786 bool val3 ;
40787 int ecode3 = 0 ;
40788 PyObject * obj0 = 0 ;
40789 PyObject * obj1 = 0 ;
40790 PyObject * obj2 = 0 ;
40791 char * kwnames[] = {
40792 (char *) "self",(char *) "pos",(char *) "enable", NULL
40793 };
40794
40795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40797 if (!SWIG_IsOK(res1)) {
40798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40799 }
40800 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40801 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40802 if (!SWIG_IsOK(ecode2)) {
40803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40804 }
40805 arg2 = static_cast< size_t >(val2);
40806 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40807 if (!SWIG_IsOK(ecode3)) {
40808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40809 }
40810 arg3 = static_cast< bool >(val3);
40811 {
40812 PyThreadState* __tstate = wxPyBeginAllowThreads();
40813 (arg1)->EnableTop(arg2,arg3);
40814 wxPyEndAllowThreads(__tstate);
40815 if (PyErr_Occurred()) SWIG_fail;
40816 }
40817 resultobj = SWIG_Py_Void();
40818 return resultobj;
40819 fail:
40820 return NULL;
40821 }
40822
40823
40824 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40825 PyObject *resultobj = 0;
40826 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40827 size_t arg2 ;
40828 bool result;
40829 void *argp1 = 0 ;
40830 int res1 = 0 ;
40831 size_t val2 ;
40832 int ecode2 = 0 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char * kwnames[] = {
40836 (char *) "self",(char *) "pos", NULL
40837 };
40838
40839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40841 if (!SWIG_IsOK(res1)) {
40842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40843 }
40844 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40845 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40846 if (!SWIG_IsOK(ecode2)) {
40847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40848 }
40849 arg2 = static_cast< size_t >(val2);
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40858 }
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj = 0;
40867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40868 size_t arg2 ;
40869 wxString *arg3 = 0 ;
40870 void *argp1 = 0 ;
40871 int res1 = 0 ;
40872 size_t val2 ;
40873 int ecode2 = 0 ;
40874 bool temp3 = false ;
40875 PyObject * obj0 = 0 ;
40876 PyObject * obj1 = 0 ;
40877 PyObject * obj2 = 0 ;
40878 char * kwnames[] = {
40879 (char *) "self",(char *) "pos",(char *) "label", NULL
40880 };
40881
40882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40889 if (!SWIG_IsOK(ecode2)) {
40890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40891 }
40892 arg2 = static_cast< size_t >(val2);
40893 {
40894 arg3 = wxString_in_helper(obj2);
40895 if (arg3 == NULL) SWIG_fail;
40896 temp3 = true;
40897 }
40898 {
40899 PyThreadState* __tstate = wxPyBeginAllowThreads();
40900 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
40901 wxPyEndAllowThreads(__tstate);
40902 if (PyErr_Occurred()) SWIG_fail;
40903 }
40904 resultobj = SWIG_Py_Void();
40905 {
40906 if (temp3)
40907 delete arg3;
40908 }
40909 return resultobj;
40910 fail:
40911 {
40912 if (temp3)
40913 delete arg3;
40914 }
40915 return NULL;
40916 }
40917
40918
40919 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40920 PyObject *resultobj = 0;
40921 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40922 size_t arg2 ;
40923 wxString result;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 size_t val2 ;
40927 int ecode2 = 0 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char * kwnames[] = {
40931 (char *) "self",(char *) "pos", NULL
40932 };
40933
40934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
40935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40936 if (!SWIG_IsOK(res1)) {
40937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40938 }
40939 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40940 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40941 if (!SWIG_IsOK(ecode2)) {
40942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40943 }
40944 arg2 = static_cast< size_t >(val2);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 {
40952 #if wxUSE_UNICODE
40953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40954 #else
40955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40956 #endif
40957 }
40958 return resultobj;
40959 fail:
40960 return NULL;
40961 }
40962
40963
40964 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40965 PyObject *resultobj = 0;
40966 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40967 wxString *arg2 = 0 ;
40968 wxString *arg3 = 0 ;
40969 int result;
40970 void *argp1 = 0 ;
40971 int res1 = 0 ;
40972 bool temp2 = false ;
40973 bool temp3 = false ;
40974 PyObject * obj0 = 0 ;
40975 PyObject * obj1 = 0 ;
40976 PyObject * obj2 = 0 ;
40977 char * kwnames[] = {
40978 (char *) "self",(char *) "menu",(char *) "item", NULL
40979 };
40980
40981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40983 if (!SWIG_IsOK(res1)) {
40984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40985 }
40986 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40987 {
40988 arg2 = wxString_in_helper(obj1);
40989 if (arg2 == NULL) SWIG_fail;
40990 temp2 = true;
40991 }
40992 {
40993 arg3 = wxString_in_helper(obj2);
40994 if (arg3 == NULL) SWIG_fail;
40995 temp3 = true;
40996 }
40997 {
40998 PyThreadState* __tstate = wxPyBeginAllowThreads();
40999 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41000 wxPyEndAllowThreads(__tstate);
41001 if (PyErr_Occurred()) SWIG_fail;
41002 }
41003 resultobj = SWIG_From_int(static_cast< int >(result));
41004 {
41005 if (temp2)
41006 delete arg2;
41007 }
41008 {
41009 if (temp3)
41010 delete arg3;
41011 }
41012 return resultobj;
41013 fail:
41014 {
41015 if (temp2)
41016 delete arg2;
41017 }
41018 {
41019 if (temp3)
41020 delete arg3;
41021 }
41022 return NULL;
41023 }
41024
41025
41026 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41027 PyObject *resultobj = 0;
41028 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41029 int arg2 ;
41030 wxMenuItem *result = 0 ;
41031 void *argp1 = 0 ;
41032 int res1 = 0 ;
41033 int val2 ;
41034 int ecode2 = 0 ;
41035 PyObject * obj0 = 0 ;
41036 PyObject * obj1 = 0 ;
41037 char * kwnames[] = {
41038 (char *) "self",(char *) "id", NULL
41039 };
41040
41041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41043 if (!SWIG_IsOK(res1)) {
41044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41045 }
41046 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41047 ecode2 = SWIG_AsVal_int(obj1, &val2);
41048 if (!SWIG_IsOK(ecode2)) {
41049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41050 }
41051 arg2 = static_cast< int >(val2);
41052 {
41053 PyThreadState* __tstate = wxPyBeginAllowThreads();
41054 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 {
41059 resultobj = wxPyMake_wxObject(result, (bool)0);
41060 }
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj = 0;
41069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41070 wxString *arg2 = 0 ;
41071 int result;
41072 void *argp1 = 0 ;
41073 int res1 = 0 ;
41074 bool temp2 = false ;
41075 PyObject * obj0 = 0 ;
41076 PyObject * obj1 = 0 ;
41077 char * kwnames[] = {
41078 (char *) "self",(char *) "title", NULL
41079 };
41080
41081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41083 if (!SWIG_IsOK(res1)) {
41084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41085 }
41086 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41087 {
41088 arg2 = wxString_in_helper(obj1);
41089 if (arg2 == NULL) SWIG_fail;
41090 temp2 = true;
41091 }
41092 {
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41095 wxPyEndAllowThreads(__tstate);
41096 if (PyErr_Occurred()) SWIG_fail;
41097 }
41098 resultobj = SWIG_From_int(static_cast< int >(result));
41099 {
41100 if (temp2)
41101 delete arg2;
41102 }
41103 return resultobj;
41104 fail:
41105 {
41106 if (temp2)
41107 delete arg2;
41108 }
41109 return NULL;
41110 }
41111
41112
41113 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41114 PyObject *resultobj = 0;
41115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41116 int arg2 ;
41117 bool arg3 ;
41118 void *argp1 = 0 ;
41119 int res1 = 0 ;
41120 int val2 ;
41121 int ecode2 = 0 ;
41122 bool val3 ;
41123 int ecode3 = 0 ;
41124 PyObject * obj0 = 0 ;
41125 PyObject * obj1 = 0 ;
41126 PyObject * obj2 = 0 ;
41127 char * kwnames[] = {
41128 (char *) "self",(char *) "id",(char *) "enable", NULL
41129 };
41130
41131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41133 if (!SWIG_IsOK(res1)) {
41134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41135 }
41136 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41137 ecode2 = SWIG_AsVal_int(obj1, &val2);
41138 if (!SWIG_IsOK(ecode2)) {
41139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41140 }
41141 arg2 = static_cast< int >(val2);
41142 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41143 if (!SWIG_IsOK(ecode3)) {
41144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41145 }
41146 arg3 = static_cast< bool >(val3);
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 (arg1)->Enable(arg2,arg3);
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 resultobj = SWIG_Py_Void();
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41161 PyObject *resultobj = 0;
41162 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41163 int arg2 ;
41164 bool arg3 ;
41165 void *argp1 = 0 ;
41166 int res1 = 0 ;
41167 int val2 ;
41168 int ecode2 = 0 ;
41169 bool val3 ;
41170 int ecode3 = 0 ;
41171 PyObject * obj0 = 0 ;
41172 PyObject * obj1 = 0 ;
41173 PyObject * obj2 = 0 ;
41174 char * kwnames[] = {
41175 (char *) "self",(char *) "id",(char *) "check", NULL
41176 };
41177
41178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41180 if (!SWIG_IsOK(res1)) {
41181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41182 }
41183 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41184 ecode2 = SWIG_AsVal_int(obj1, &val2);
41185 if (!SWIG_IsOK(ecode2)) {
41186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41187 }
41188 arg2 = static_cast< int >(val2);
41189 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41190 if (!SWIG_IsOK(ecode3)) {
41191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41192 }
41193 arg3 = static_cast< bool >(val3);
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 (arg1)->Check(arg2,arg3);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 resultobj = SWIG_Py_Void();
41201 return resultobj;
41202 fail:
41203 return NULL;
41204 }
41205
41206
41207 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41208 PyObject *resultobj = 0;
41209 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41210 int arg2 ;
41211 bool result;
41212 void *argp1 = 0 ;
41213 int res1 = 0 ;
41214 int val2 ;
41215 int ecode2 = 0 ;
41216 PyObject * obj0 = 0 ;
41217 PyObject * obj1 = 0 ;
41218 char * kwnames[] = {
41219 (char *) "self",(char *) "id", NULL
41220 };
41221
41222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41224 if (!SWIG_IsOK(res1)) {
41225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41226 }
41227 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41228 ecode2 = SWIG_AsVal_int(obj1, &val2);
41229 if (!SWIG_IsOK(ecode2)) {
41230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41231 }
41232 arg2 = static_cast< int >(val2);
41233 {
41234 PyThreadState* __tstate = wxPyBeginAllowThreads();
41235 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41236 wxPyEndAllowThreads(__tstate);
41237 if (PyErr_Occurred()) SWIG_fail;
41238 }
41239 {
41240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41241 }
41242 return resultobj;
41243 fail:
41244 return NULL;
41245 }
41246
41247
41248 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41249 PyObject *resultobj = 0;
41250 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41251 int arg2 ;
41252 bool result;
41253 void *argp1 = 0 ;
41254 int res1 = 0 ;
41255 int val2 ;
41256 int ecode2 = 0 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 char * kwnames[] = {
41260 (char *) "self",(char *) "id", NULL
41261 };
41262
41263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41265 if (!SWIG_IsOK(res1)) {
41266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41267 }
41268 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41269 ecode2 = SWIG_AsVal_int(obj1, &val2);
41270 if (!SWIG_IsOK(ecode2)) {
41271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41272 }
41273 arg2 = static_cast< int >(val2);
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41277 wxPyEndAllowThreads(__tstate);
41278 if (PyErr_Occurred()) SWIG_fail;
41279 }
41280 {
41281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41282 }
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41290 PyObject *resultobj = 0;
41291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41292 int arg2 ;
41293 wxString *arg3 = 0 ;
41294 void *argp1 = 0 ;
41295 int res1 = 0 ;
41296 int val2 ;
41297 int ecode2 = 0 ;
41298 bool temp3 = false ;
41299 PyObject * obj0 = 0 ;
41300 PyObject * obj1 = 0 ;
41301 PyObject * obj2 = 0 ;
41302 char * kwnames[] = {
41303 (char *) "self",(char *) "id",(char *) "label", NULL
41304 };
41305
41306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41308 if (!SWIG_IsOK(res1)) {
41309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41310 }
41311 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41312 ecode2 = SWIG_AsVal_int(obj1, &val2);
41313 if (!SWIG_IsOK(ecode2)) {
41314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41315 }
41316 arg2 = static_cast< int >(val2);
41317 {
41318 arg3 = wxString_in_helper(obj2);
41319 if (arg3 == NULL) SWIG_fail;
41320 temp3 = true;
41321 }
41322 {
41323 PyThreadState* __tstate = wxPyBeginAllowThreads();
41324 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41325 wxPyEndAllowThreads(__tstate);
41326 if (PyErr_Occurred()) SWIG_fail;
41327 }
41328 resultobj = SWIG_Py_Void();
41329 {
41330 if (temp3)
41331 delete arg3;
41332 }
41333 return resultobj;
41334 fail:
41335 {
41336 if (temp3)
41337 delete arg3;
41338 }
41339 return NULL;
41340 }
41341
41342
41343 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj = 0;
41345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41346 int arg2 ;
41347 wxString result;
41348 void *argp1 = 0 ;
41349 int res1 = 0 ;
41350 int val2 ;
41351 int ecode2 = 0 ;
41352 PyObject * obj0 = 0 ;
41353 PyObject * obj1 = 0 ;
41354 char * kwnames[] = {
41355 (char *) "self",(char *) "id", NULL
41356 };
41357
41358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41360 if (!SWIG_IsOK(res1)) {
41361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41362 }
41363 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41364 ecode2 = SWIG_AsVal_int(obj1, &val2);
41365 if (!SWIG_IsOK(ecode2)) {
41366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41367 }
41368 arg2 = static_cast< int >(val2);
41369 {
41370 PyThreadState* __tstate = wxPyBeginAllowThreads();
41371 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41372 wxPyEndAllowThreads(__tstate);
41373 if (PyErr_Occurred()) SWIG_fail;
41374 }
41375 {
41376 #if wxUSE_UNICODE
41377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41378 #else
41379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41380 #endif
41381 }
41382 return resultobj;
41383 fail:
41384 return NULL;
41385 }
41386
41387
41388 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41389 PyObject *resultobj = 0;
41390 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41391 int arg2 ;
41392 wxString *arg3 = 0 ;
41393 void *argp1 = 0 ;
41394 int res1 = 0 ;
41395 int val2 ;
41396 int ecode2 = 0 ;
41397 bool temp3 = false ;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 PyObject * obj2 = 0 ;
41401 char * kwnames[] = {
41402 (char *) "self",(char *) "id",(char *) "helpString", NULL
41403 };
41404
41405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41407 if (!SWIG_IsOK(res1)) {
41408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41409 }
41410 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41411 ecode2 = SWIG_AsVal_int(obj1, &val2);
41412 if (!SWIG_IsOK(ecode2)) {
41413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41414 }
41415 arg2 = static_cast< int >(val2);
41416 {
41417 arg3 = wxString_in_helper(obj2);
41418 if (arg3 == NULL) SWIG_fail;
41419 temp3 = true;
41420 }
41421 {
41422 PyThreadState* __tstate = wxPyBeginAllowThreads();
41423 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41424 wxPyEndAllowThreads(__tstate);
41425 if (PyErr_Occurred()) SWIG_fail;
41426 }
41427 resultobj = SWIG_Py_Void();
41428 {
41429 if (temp3)
41430 delete arg3;
41431 }
41432 return resultobj;
41433 fail:
41434 {
41435 if (temp3)
41436 delete arg3;
41437 }
41438 return NULL;
41439 }
41440
41441
41442 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41443 PyObject *resultobj = 0;
41444 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41445 int arg2 ;
41446 wxString result;
41447 void *argp1 = 0 ;
41448 int res1 = 0 ;
41449 int val2 ;
41450 int ecode2 = 0 ;
41451 PyObject * obj0 = 0 ;
41452 PyObject * obj1 = 0 ;
41453 char * kwnames[] = {
41454 (char *) "self",(char *) "id", NULL
41455 };
41456
41457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41459 if (!SWIG_IsOK(res1)) {
41460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41461 }
41462 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41463 ecode2 = SWIG_AsVal_int(obj1, &val2);
41464 if (!SWIG_IsOK(ecode2)) {
41465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41466 }
41467 arg2 = static_cast< int >(val2);
41468 {
41469 PyThreadState* __tstate = wxPyBeginAllowThreads();
41470 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 {
41475 #if wxUSE_UNICODE
41476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41477 #else
41478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41479 #endif
41480 }
41481 return resultobj;
41482 fail:
41483 return NULL;
41484 }
41485
41486
41487 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41488 PyObject *resultobj = 0;
41489 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41490 wxFrame *result = 0 ;
41491 void *argp1 = 0 ;
41492 int res1 = 0 ;
41493 PyObject *swig_obj[1] ;
41494
41495 if (!args) SWIG_fail;
41496 swig_obj[0] = args;
41497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41498 if (!SWIG_IsOK(res1)) {
41499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41500 }
41501 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41502 {
41503 PyThreadState* __tstate = wxPyBeginAllowThreads();
41504 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41505 wxPyEndAllowThreads(__tstate);
41506 if (PyErr_Occurred()) SWIG_fail;
41507 }
41508 {
41509 resultobj = wxPyMake_wxObject(result, (bool)0);
41510 }
41511 return resultobj;
41512 fail:
41513 return NULL;
41514 }
41515
41516
41517 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41518 PyObject *resultobj = 0;
41519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41520 bool result;
41521 void *argp1 = 0 ;
41522 int res1 = 0 ;
41523 PyObject *swig_obj[1] ;
41524
41525 if (!args) SWIG_fail;
41526 swig_obj[0] = args;
41527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41528 if (!SWIG_IsOK(res1)) {
41529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41530 }
41531 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41532 {
41533 PyThreadState* __tstate = wxPyBeginAllowThreads();
41534 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41535 wxPyEndAllowThreads(__tstate);
41536 if (PyErr_Occurred()) SWIG_fail;
41537 }
41538 {
41539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41540 }
41541 return resultobj;
41542 fail:
41543 return NULL;
41544 }
41545
41546
41547 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj = 0;
41549 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41550 wxFrame *arg2 = (wxFrame *) 0 ;
41551 void *argp1 = 0 ;
41552 int res1 = 0 ;
41553 void *argp2 = 0 ;
41554 int res2 = 0 ;
41555 PyObject * obj0 = 0 ;
41556 PyObject * obj1 = 0 ;
41557 char * kwnames[] = {
41558 (char *) "self",(char *) "frame", NULL
41559 };
41560
41561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41563 if (!SWIG_IsOK(res1)) {
41564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41565 }
41566 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41568 if (!SWIG_IsOK(res2)) {
41569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41570 }
41571 arg2 = reinterpret_cast< wxFrame * >(argp2);
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 (arg1)->Attach(arg2);
41575 wxPyEndAllowThreads(__tstate);
41576 if (PyErr_Occurred()) SWIG_fail;
41577 }
41578 resultobj = SWIG_Py_Void();
41579 return resultobj;
41580 fail:
41581 return NULL;
41582 }
41583
41584
41585 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41586 PyObject *resultobj = 0;
41587 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41588 void *argp1 = 0 ;
41589 int res1 = 0 ;
41590 PyObject *swig_obj[1] ;
41591
41592 if (!args) SWIG_fail;
41593 swig_obj[0] = args;
41594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41595 if (!SWIG_IsOK(res1)) {
41596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41597 }
41598 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 (arg1)->Detach();
41602 wxPyEndAllowThreads(__tstate);
41603 if (PyErr_Occurred()) SWIG_fail;
41604 }
41605 resultobj = SWIG_Py_Void();
41606 return resultobj;
41607 fail:
41608 return NULL;
41609 }
41610
41611
41612 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41613 PyObject *resultobj = 0;
41614 bool arg1 ;
41615 bool val1 ;
41616 int ecode1 = 0 ;
41617 PyObject * obj0 = 0 ;
41618 char * kwnames[] = {
41619 (char *) "enable", NULL
41620 };
41621
41622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41623 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41624 if (!SWIG_IsOK(ecode1)) {
41625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41626 }
41627 arg1 = static_cast< bool >(val1);
41628 {
41629 PyThreadState* __tstate = wxPyBeginAllowThreads();
41630 wxMenuBar::SetAutoWindowMenu(arg1);
41631 wxPyEndAllowThreads(__tstate);
41632 if (PyErr_Occurred()) SWIG_fail;
41633 }
41634 resultobj = SWIG_Py_Void();
41635 return resultobj;
41636 fail:
41637 return NULL;
41638 }
41639
41640
41641 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41642 PyObject *resultobj = 0;
41643 bool result;
41644
41645 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41646 {
41647 PyThreadState* __tstate = wxPyBeginAllowThreads();
41648 result = (bool)wxMenuBar::GetAutoWindowMenu();
41649 wxPyEndAllowThreads(__tstate);
41650 if (PyErr_Occurred()) SWIG_fail;
41651 }
41652 {
41653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41654 }
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41662 PyObject *obj;
41663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41664 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41665 return SWIG_Py_Void();
41666 }
41667
41668 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41669 return SWIG_Python_InitShadowInstance(args);
41670 }
41671
41672 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj = 0;
41674 wxMenu *arg1 = (wxMenu *) NULL ;
41675 int arg2 = (int) wxID_ANY ;
41676 wxString const &arg3_defvalue = wxPyEmptyString ;
41677 wxString *arg3 = (wxString *) &arg3_defvalue ;
41678 wxString const &arg4_defvalue = wxPyEmptyString ;
41679 wxString *arg4 = (wxString *) &arg4_defvalue ;
41680 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41681 wxMenu *arg6 = (wxMenu *) NULL ;
41682 wxMenuItem *result = 0 ;
41683 void *argp1 = 0 ;
41684 int res1 = 0 ;
41685 int val2 ;
41686 int ecode2 = 0 ;
41687 bool temp3 = false ;
41688 bool temp4 = false ;
41689 int val5 ;
41690 int ecode5 = 0 ;
41691 void *argp6 = 0 ;
41692 int res6 = 0 ;
41693 PyObject * obj0 = 0 ;
41694 PyObject * obj1 = 0 ;
41695 PyObject * obj2 = 0 ;
41696 PyObject * obj3 = 0 ;
41697 PyObject * obj4 = 0 ;
41698 PyObject * obj5 = 0 ;
41699 char * kwnames[] = {
41700 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41701 };
41702
41703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41704 if (obj0) {
41705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41706 if (!SWIG_IsOK(res1)) {
41707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41708 }
41709 arg1 = reinterpret_cast< wxMenu * >(argp1);
41710 }
41711 if (obj1) {
41712 ecode2 = SWIG_AsVal_int(obj1, &val2);
41713 if (!SWIG_IsOK(ecode2)) {
41714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41715 }
41716 arg2 = static_cast< int >(val2);
41717 }
41718 if (obj2) {
41719 {
41720 arg3 = wxString_in_helper(obj2);
41721 if (arg3 == NULL) SWIG_fail;
41722 temp3 = true;
41723 }
41724 }
41725 if (obj3) {
41726 {
41727 arg4 = wxString_in_helper(obj3);
41728 if (arg4 == NULL) SWIG_fail;
41729 temp4 = true;
41730 }
41731 }
41732 if (obj4) {
41733 ecode5 = SWIG_AsVal_int(obj4, &val5);
41734 if (!SWIG_IsOK(ecode5)) {
41735 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41736 }
41737 arg5 = static_cast< wxItemKind >(val5);
41738 }
41739 if (obj5) {
41740 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41741 if (!SWIG_IsOK(res6)) {
41742 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41743 }
41744 arg6 = reinterpret_cast< wxMenu * >(argp6);
41745 }
41746 {
41747 PyThreadState* __tstate = wxPyBeginAllowThreads();
41748 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41749 wxPyEndAllowThreads(__tstate);
41750 if (PyErr_Occurred()) SWIG_fail;
41751 }
41752 {
41753 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41754 }
41755 {
41756 if (temp3)
41757 delete arg3;
41758 }
41759 {
41760 if (temp4)
41761 delete arg4;
41762 }
41763 return resultobj;
41764 fail:
41765 {
41766 if (temp3)
41767 delete arg3;
41768 }
41769 {
41770 if (temp4)
41771 delete arg4;
41772 }
41773 return NULL;
41774 }
41775
41776
41777 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41778 PyObject *resultobj = 0;
41779 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41780 void *argp1 = 0 ;
41781 int res1 = 0 ;
41782 PyObject *swig_obj[1] ;
41783
41784 if (!args) SWIG_fail;
41785 swig_obj[0] = args;
41786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41787 if (!SWIG_IsOK(res1)) {
41788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41789 }
41790 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 delete arg1;
41794
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 resultobj = SWIG_Py_Void();
41799 return resultobj;
41800 fail:
41801 return NULL;
41802 }
41803
41804
41805 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41806 PyObject *resultobj = 0;
41807 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41808 wxMenu *result = 0 ;
41809 void *argp1 = 0 ;
41810 int res1 = 0 ;
41811 PyObject *swig_obj[1] ;
41812
41813 if (!args) SWIG_fail;
41814 swig_obj[0] = args;
41815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41816 if (!SWIG_IsOK(res1)) {
41817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41818 }
41819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41820 {
41821 PyThreadState* __tstate = wxPyBeginAllowThreads();
41822 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41823 wxPyEndAllowThreads(__tstate);
41824 if (PyErr_Occurred()) SWIG_fail;
41825 }
41826 {
41827 resultobj = wxPyMake_wxObject(result, 0);
41828 }
41829 return resultobj;
41830 fail:
41831 return NULL;
41832 }
41833
41834
41835 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41836 PyObject *resultobj = 0;
41837 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41838 wxMenu *arg2 = (wxMenu *) 0 ;
41839 void *argp1 = 0 ;
41840 int res1 = 0 ;
41841 void *argp2 = 0 ;
41842 int res2 = 0 ;
41843 PyObject * obj0 = 0 ;
41844 PyObject * obj1 = 0 ;
41845 char * kwnames[] = {
41846 (char *) "self",(char *) "menu", NULL
41847 };
41848
41849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41851 if (!SWIG_IsOK(res1)) {
41852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41853 }
41854 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41856 if (!SWIG_IsOK(res2)) {
41857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41858 }
41859 arg2 = reinterpret_cast< wxMenu * >(argp2);
41860 {
41861 PyThreadState* __tstate = wxPyBeginAllowThreads();
41862 (arg1)->SetMenu(arg2);
41863 wxPyEndAllowThreads(__tstate);
41864 if (PyErr_Occurred()) SWIG_fail;
41865 }
41866 resultobj = SWIG_Py_Void();
41867 return resultobj;
41868 fail:
41869 return NULL;
41870 }
41871
41872
41873 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41874 PyObject *resultobj = 0;
41875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41876 int arg2 ;
41877 void *argp1 = 0 ;
41878 int res1 = 0 ;
41879 int val2 ;
41880 int ecode2 = 0 ;
41881 PyObject * obj0 = 0 ;
41882 PyObject * obj1 = 0 ;
41883 char * kwnames[] = {
41884 (char *) "self",(char *) "id", NULL
41885 };
41886
41887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
41888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41889 if (!SWIG_IsOK(res1)) {
41890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41891 }
41892 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41893 ecode2 = SWIG_AsVal_int(obj1, &val2);
41894 if (!SWIG_IsOK(ecode2)) {
41895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
41896 }
41897 arg2 = static_cast< int >(val2);
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 (arg1)->SetId(arg2);
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 resultobj = SWIG_Py_Void();
41905 return resultobj;
41906 fail:
41907 return NULL;
41908 }
41909
41910
41911 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41912 PyObject *resultobj = 0;
41913 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41914 int result;
41915 void *argp1 = 0 ;
41916 int res1 = 0 ;
41917 PyObject *swig_obj[1] ;
41918
41919 if (!args) SWIG_fail;
41920 swig_obj[0] = args;
41921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41922 if (!SWIG_IsOK(res1)) {
41923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41924 }
41925 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41926 {
41927 PyThreadState* __tstate = wxPyBeginAllowThreads();
41928 result = (int)((wxMenuItem const *)arg1)->GetId();
41929 wxPyEndAllowThreads(__tstate);
41930 if (PyErr_Occurred()) SWIG_fail;
41931 }
41932 resultobj = SWIG_From_int(static_cast< int >(result));
41933 return resultobj;
41934 fail:
41935 return NULL;
41936 }
41937
41938
41939 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41940 PyObject *resultobj = 0;
41941 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41942 bool result;
41943 void *argp1 = 0 ;
41944 int res1 = 0 ;
41945 PyObject *swig_obj[1] ;
41946
41947 if (!args) SWIG_fail;
41948 swig_obj[0] = args;
41949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41950 if (!SWIG_IsOK(res1)) {
41951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41952 }
41953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41954 {
41955 PyThreadState* __tstate = wxPyBeginAllowThreads();
41956 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
41957 wxPyEndAllowThreads(__tstate);
41958 if (PyErr_Occurred()) SWIG_fail;
41959 }
41960 {
41961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41962 }
41963 return resultobj;
41964 fail:
41965 return NULL;
41966 }
41967
41968
41969 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41970 PyObject *resultobj = 0;
41971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41972 wxString *arg2 = 0 ;
41973 void *argp1 = 0 ;
41974 int res1 = 0 ;
41975 bool temp2 = false ;
41976 PyObject * obj0 = 0 ;
41977 PyObject * obj1 = 0 ;
41978 char * kwnames[] = {
41979 (char *) "self",(char *) "str", NULL
41980 };
41981
41982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
41983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41984 if (!SWIG_IsOK(res1)) {
41985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41986 }
41987 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41988 {
41989 arg2 = wxString_in_helper(obj1);
41990 if (arg2 == NULL) SWIG_fail;
41991 temp2 = true;
41992 }
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 (arg1)->SetText((wxString const &)*arg2);
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 resultobj = SWIG_Py_Void();
42000 {
42001 if (temp2)
42002 delete arg2;
42003 }
42004 return resultobj;
42005 fail:
42006 {
42007 if (temp2)
42008 delete arg2;
42009 }
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42015 PyObject *resultobj = 0;
42016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42017 wxString result;
42018 void *argp1 = 0 ;
42019 int res1 = 0 ;
42020 PyObject *swig_obj[1] ;
42021
42022 if (!args) SWIG_fail;
42023 swig_obj[0] = args;
42024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42025 if (!SWIG_IsOK(res1)) {
42026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42027 }
42028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = ((wxMenuItem const *)arg1)->GetLabel();
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 {
42036 #if wxUSE_UNICODE
42037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42038 #else
42039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42040 #endif
42041 }
42042 return resultobj;
42043 fail:
42044 return NULL;
42045 }
42046
42047
42048 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42049 PyObject *resultobj = 0;
42050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42051 wxString *result = 0 ;
42052 void *argp1 = 0 ;
42053 int res1 = 0 ;
42054 PyObject *swig_obj[1] ;
42055
42056 if (!args) SWIG_fail;
42057 swig_obj[0] = args;
42058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42059 if (!SWIG_IsOK(res1)) {
42060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42061 }
42062 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42063 {
42064 PyThreadState* __tstate = wxPyBeginAllowThreads();
42065 {
42066 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42067 result = (wxString *) &_result_ref;
42068 }
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 {
42073 #if wxUSE_UNICODE
42074 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42075 #else
42076 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42077 #endif
42078 }
42079 return resultobj;
42080 fail:
42081 return NULL;
42082 }
42083
42084
42085 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42086 PyObject *resultobj = 0;
42087 wxString *arg1 = 0 ;
42088 wxString result;
42089 bool temp1 = false ;
42090 PyObject * obj0 = 0 ;
42091 char * kwnames[] = {
42092 (char *) "text", NULL
42093 };
42094
42095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42096 {
42097 arg1 = wxString_in_helper(obj0);
42098 if (arg1 == NULL) SWIG_fail;
42099 temp1 = true;
42100 }
42101 {
42102 PyThreadState* __tstate = wxPyBeginAllowThreads();
42103 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42104 wxPyEndAllowThreads(__tstate);
42105 if (PyErr_Occurred()) SWIG_fail;
42106 }
42107 {
42108 #if wxUSE_UNICODE
42109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42110 #else
42111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42112 #endif
42113 }
42114 {
42115 if (temp1)
42116 delete arg1;
42117 }
42118 return resultobj;
42119 fail:
42120 {
42121 if (temp1)
42122 delete arg1;
42123 }
42124 return NULL;
42125 }
42126
42127
42128 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42129 PyObject *resultobj = 0;
42130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42131 wxItemKind result;
42132 void *argp1 = 0 ;
42133 int res1 = 0 ;
42134 PyObject *swig_obj[1] ;
42135
42136 if (!args) SWIG_fail;
42137 swig_obj[0] = args;
42138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42139 if (!SWIG_IsOK(res1)) {
42140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42141 }
42142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42146 wxPyEndAllowThreads(__tstate);
42147 if (PyErr_Occurred()) SWIG_fail;
42148 }
42149 resultobj = SWIG_From_int(static_cast< int >(result));
42150 return resultobj;
42151 fail:
42152 return NULL;
42153 }
42154
42155
42156 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42157 PyObject *resultobj = 0;
42158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42159 wxItemKind arg2 ;
42160 void *argp1 = 0 ;
42161 int res1 = 0 ;
42162 int val2 ;
42163 int ecode2 = 0 ;
42164 PyObject * obj0 = 0 ;
42165 PyObject * obj1 = 0 ;
42166 char * kwnames[] = {
42167 (char *) "self",(char *) "kind", NULL
42168 };
42169
42170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42172 if (!SWIG_IsOK(res1)) {
42173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42174 }
42175 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42176 ecode2 = SWIG_AsVal_int(obj1, &val2);
42177 if (!SWIG_IsOK(ecode2)) {
42178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42179 }
42180 arg2 = static_cast< wxItemKind >(val2);
42181 {
42182 PyThreadState* __tstate = wxPyBeginAllowThreads();
42183 (arg1)->SetKind(arg2);
42184 wxPyEndAllowThreads(__tstate);
42185 if (PyErr_Occurred()) SWIG_fail;
42186 }
42187 resultobj = SWIG_Py_Void();
42188 return resultobj;
42189 fail:
42190 return NULL;
42191 }
42192
42193
42194 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42195 PyObject *resultobj = 0;
42196 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42197 bool arg2 ;
42198 void *argp1 = 0 ;
42199 int res1 = 0 ;
42200 bool val2 ;
42201 int ecode2 = 0 ;
42202 PyObject * obj0 = 0 ;
42203 PyObject * obj1 = 0 ;
42204 char * kwnames[] = {
42205 (char *) "self",(char *) "checkable", NULL
42206 };
42207
42208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42210 if (!SWIG_IsOK(res1)) {
42211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42212 }
42213 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42215 if (!SWIG_IsOK(ecode2)) {
42216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42217 }
42218 arg2 = static_cast< bool >(val2);
42219 {
42220 PyThreadState* __tstate = wxPyBeginAllowThreads();
42221 (arg1)->SetCheckable(arg2);
42222 wxPyEndAllowThreads(__tstate);
42223 if (PyErr_Occurred()) SWIG_fail;
42224 }
42225 resultobj = SWIG_Py_Void();
42226 return resultobj;
42227 fail:
42228 return NULL;
42229 }
42230
42231
42232 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42233 PyObject *resultobj = 0;
42234 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42235 bool result;
42236 void *argp1 = 0 ;
42237 int res1 = 0 ;
42238 PyObject *swig_obj[1] ;
42239
42240 if (!args) SWIG_fail;
42241 swig_obj[0] = args;
42242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42243 if (!SWIG_IsOK(res1)) {
42244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42245 }
42246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42247 {
42248 PyThreadState* __tstate = wxPyBeginAllowThreads();
42249 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42250 wxPyEndAllowThreads(__tstate);
42251 if (PyErr_Occurred()) SWIG_fail;
42252 }
42253 {
42254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42255 }
42256 return resultobj;
42257 fail:
42258 return NULL;
42259 }
42260
42261
42262 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42263 PyObject *resultobj = 0;
42264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42265 bool result;
42266 void *argp1 = 0 ;
42267 int res1 = 0 ;
42268 PyObject *swig_obj[1] ;
42269
42270 if (!args) SWIG_fail;
42271 swig_obj[0] = args;
42272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42273 if (!SWIG_IsOK(res1)) {
42274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42275 }
42276 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42277 {
42278 PyThreadState* __tstate = wxPyBeginAllowThreads();
42279 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42280 wxPyEndAllowThreads(__tstate);
42281 if (PyErr_Occurred()) SWIG_fail;
42282 }
42283 {
42284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42285 }
42286 return resultobj;
42287 fail:
42288 return NULL;
42289 }
42290
42291
42292 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42293 PyObject *resultobj = 0;
42294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42295 wxMenu *arg2 = (wxMenu *) 0 ;
42296 void *argp1 = 0 ;
42297 int res1 = 0 ;
42298 void *argp2 = 0 ;
42299 int res2 = 0 ;
42300 PyObject * obj0 = 0 ;
42301 PyObject * obj1 = 0 ;
42302 char * kwnames[] = {
42303 (char *) "self",(char *) "menu", NULL
42304 };
42305
42306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42308 if (!SWIG_IsOK(res1)) {
42309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42310 }
42311 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42313 if (!SWIG_IsOK(res2)) {
42314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42315 }
42316 arg2 = reinterpret_cast< wxMenu * >(argp2);
42317 {
42318 PyThreadState* __tstate = wxPyBeginAllowThreads();
42319 (arg1)->SetSubMenu(arg2);
42320 wxPyEndAllowThreads(__tstate);
42321 if (PyErr_Occurred()) SWIG_fail;
42322 }
42323 resultobj = SWIG_Py_Void();
42324 return resultobj;
42325 fail:
42326 return NULL;
42327 }
42328
42329
42330 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42331 PyObject *resultobj = 0;
42332 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42333 wxMenu *result = 0 ;
42334 void *argp1 = 0 ;
42335 int res1 = 0 ;
42336 PyObject *swig_obj[1] ;
42337
42338 if (!args) SWIG_fail;
42339 swig_obj[0] = args;
42340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42341 if (!SWIG_IsOK(res1)) {
42342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42343 }
42344 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42348 wxPyEndAllowThreads(__tstate);
42349 if (PyErr_Occurred()) SWIG_fail;
42350 }
42351 {
42352 resultobj = wxPyMake_wxObject(result, 0);
42353 }
42354 return resultobj;
42355 fail:
42356 return NULL;
42357 }
42358
42359
42360 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42361 PyObject *resultobj = 0;
42362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42363 bool arg2 = (bool) true ;
42364 void *argp1 = 0 ;
42365 int res1 = 0 ;
42366 bool val2 ;
42367 int ecode2 = 0 ;
42368 PyObject * obj0 = 0 ;
42369 PyObject * obj1 = 0 ;
42370 char * kwnames[] = {
42371 (char *) "self",(char *) "enable", NULL
42372 };
42373
42374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42376 if (!SWIG_IsOK(res1)) {
42377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42378 }
42379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42380 if (obj1) {
42381 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42382 if (!SWIG_IsOK(ecode2)) {
42383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42384 }
42385 arg2 = static_cast< bool >(val2);
42386 }
42387 {
42388 PyThreadState* __tstate = wxPyBeginAllowThreads();
42389 (arg1)->Enable(arg2);
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 resultobj = SWIG_Py_Void();
42394 return resultobj;
42395 fail:
42396 return NULL;
42397 }
42398
42399
42400 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42401 PyObject *resultobj = 0;
42402 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42403 bool result;
42404 void *argp1 = 0 ;
42405 int res1 = 0 ;
42406 PyObject *swig_obj[1] ;
42407
42408 if (!args) SWIG_fail;
42409 swig_obj[0] = args;
42410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42411 if (!SWIG_IsOK(res1)) {
42412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42413 }
42414 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42415 {
42416 PyThreadState* __tstate = wxPyBeginAllowThreads();
42417 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42418 wxPyEndAllowThreads(__tstate);
42419 if (PyErr_Occurred()) SWIG_fail;
42420 }
42421 {
42422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42423 }
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42431 PyObject *resultobj = 0;
42432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42433 bool arg2 = (bool) true ;
42434 void *argp1 = 0 ;
42435 int res1 = 0 ;
42436 bool val2 ;
42437 int ecode2 = 0 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 char * kwnames[] = {
42441 (char *) "self",(char *) "check", NULL
42442 };
42443
42444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42450 if (obj1) {
42451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42452 if (!SWIG_IsOK(ecode2)) {
42453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42454 }
42455 arg2 = static_cast< bool >(val2);
42456 }
42457 {
42458 PyThreadState* __tstate = wxPyBeginAllowThreads();
42459 (arg1)->Check(arg2);
42460 wxPyEndAllowThreads(__tstate);
42461 if (PyErr_Occurred()) SWIG_fail;
42462 }
42463 resultobj = SWIG_Py_Void();
42464 return resultobj;
42465 fail:
42466 return NULL;
42467 }
42468
42469
42470 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42471 PyObject *resultobj = 0;
42472 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42473 bool result;
42474 void *argp1 = 0 ;
42475 int res1 = 0 ;
42476 PyObject *swig_obj[1] ;
42477
42478 if (!args) SWIG_fail;
42479 swig_obj[0] = args;
42480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42481 if (!SWIG_IsOK(res1)) {
42482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42483 }
42484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42485 {
42486 PyThreadState* __tstate = wxPyBeginAllowThreads();
42487 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42488 wxPyEndAllowThreads(__tstate);
42489 if (PyErr_Occurred()) SWIG_fail;
42490 }
42491 {
42492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42493 }
42494 return resultobj;
42495 fail:
42496 return NULL;
42497 }
42498
42499
42500 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42501 PyObject *resultobj = 0;
42502 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42503 void *argp1 = 0 ;
42504 int res1 = 0 ;
42505 PyObject *swig_obj[1] ;
42506
42507 if (!args) SWIG_fail;
42508 swig_obj[0] = args;
42509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42510 if (!SWIG_IsOK(res1)) {
42511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42512 }
42513 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42514 {
42515 PyThreadState* __tstate = wxPyBeginAllowThreads();
42516 (arg1)->Toggle();
42517 wxPyEndAllowThreads(__tstate);
42518 if (PyErr_Occurred()) SWIG_fail;
42519 }
42520 resultobj = SWIG_Py_Void();
42521 return resultobj;
42522 fail:
42523 return NULL;
42524 }
42525
42526
42527 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42528 PyObject *resultobj = 0;
42529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42530 wxString *arg2 = 0 ;
42531 void *argp1 = 0 ;
42532 int res1 = 0 ;
42533 bool temp2 = false ;
42534 PyObject * obj0 = 0 ;
42535 PyObject * obj1 = 0 ;
42536 char * kwnames[] = {
42537 (char *) "self",(char *) "str", NULL
42538 };
42539
42540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42542 if (!SWIG_IsOK(res1)) {
42543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42544 }
42545 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42546 {
42547 arg2 = wxString_in_helper(obj1);
42548 if (arg2 == NULL) SWIG_fail;
42549 temp2 = true;
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 (arg1)->SetHelp((wxString const &)*arg2);
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 resultobj = SWIG_Py_Void();
42558 {
42559 if (temp2)
42560 delete arg2;
42561 }
42562 return resultobj;
42563 fail:
42564 {
42565 if (temp2)
42566 delete arg2;
42567 }
42568 return NULL;
42569 }
42570
42571
42572 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42573 PyObject *resultobj = 0;
42574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42575 wxString *result = 0 ;
42576 void *argp1 = 0 ;
42577 int res1 = 0 ;
42578 PyObject *swig_obj[1] ;
42579
42580 if (!args) SWIG_fail;
42581 swig_obj[0] = args;
42582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42583 if (!SWIG_IsOK(res1)) {
42584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42585 }
42586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42587 {
42588 PyThreadState* __tstate = wxPyBeginAllowThreads();
42589 {
42590 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42591 result = (wxString *) &_result_ref;
42592 }
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 {
42597 #if wxUSE_UNICODE
42598 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42599 #else
42600 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42601 #endif
42602 }
42603 return resultobj;
42604 fail:
42605 return NULL;
42606 }
42607
42608
42609 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42610 PyObject *resultobj = 0;
42611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42612 wxAcceleratorEntry *result = 0 ;
42613 void *argp1 = 0 ;
42614 int res1 = 0 ;
42615 PyObject *swig_obj[1] ;
42616
42617 if (!args) SWIG_fail;
42618 swig_obj[0] = args;
42619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42620 if (!SWIG_IsOK(res1)) {
42621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42622 }
42623 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42624 {
42625 PyThreadState* __tstate = wxPyBeginAllowThreads();
42626 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42627 wxPyEndAllowThreads(__tstate);
42628 if (PyErr_Occurred()) SWIG_fail;
42629 }
42630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42631 return resultobj;
42632 fail:
42633 return NULL;
42634 }
42635
42636
42637 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42638 PyObject *resultobj = 0;
42639 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42640 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42641 void *argp1 = 0 ;
42642 int res1 = 0 ;
42643 void *argp2 = 0 ;
42644 int res2 = 0 ;
42645 PyObject * obj0 = 0 ;
42646 PyObject * obj1 = 0 ;
42647 char * kwnames[] = {
42648 (char *) "self",(char *) "accel", NULL
42649 };
42650
42651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42653 if (!SWIG_IsOK(res1)) {
42654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42655 }
42656 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42658 if (!SWIG_IsOK(res2)) {
42659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42660 }
42661 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42662 {
42663 PyThreadState* __tstate = wxPyBeginAllowThreads();
42664 (arg1)->SetAccel(arg2);
42665 wxPyEndAllowThreads(__tstate);
42666 if (PyErr_Occurred()) SWIG_fail;
42667 }
42668 resultobj = SWIG_Py_Void();
42669 return resultobj;
42670 fail:
42671 return NULL;
42672 }
42673
42674
42675 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42676 PyObject *resultobj = 0;
42677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42678 wxBitmap *arg2 = 0 ;
42679 void *argp1 = 0 ;
42680 int res1 = 0 ;
42681 void *argp2 = 0 ;
42682 int res2 = 0 ;
42683 PyObject * obj0 = 0 ;
42684 PyObject * obj1 = 0 ;
42685 char * kwnames[] = {
42686 (char *) "self",(char *) "bitmap", NULL
42687 };
42688
42689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42691 if (!SWIG_IsOK(res1)) {
42692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42693 }
42694 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42696 if (!SWIG_IsOK(res2)) {
42697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42698 }
42699 if (!argp2) {
42700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42701 }
42702 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42703 {
42704 PyThreadState* __tstate = wxPyBeginAllowThreads();
42705 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42706 wxPyEndAllowThreads(__tstate);
42707 if (PyErr_Occurred()) SWIG_fail;
42708 }
42709 resultobj = SWIG_Py_Void();
42710 return resultobj;
42711 fail:
42712 return NULL;
42713 }
42714
42715
42716 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42717 PyObject *resultobj = 0;
42718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42719 wxBitmap *result = 0 ;
42720 void *argp1 = 0 ;
42721 int res1 = 0 ;
42722 PyObject *swig_obj[1] ;
42723
42724 if (!args) SWIG_fail;
42725 swig_obj[0] = args;
42726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42727 if (!SWIG_IsOK(res1)) {
42728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42729 }
42730 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 {
42734 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42735 result = (wxBitmap *) &_result_ref;
42736 }
42737 wxPyEndAllowThreads(__tstate);
42738 if (PyErr_Occurred()) SWIG_fail;
42739 }
42740 {
42741 wxBitmap* resultptr = new wxBitmap(*result);
42742 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42743 }
42744 return resultobj;
42745 fail:
42746 return NULL;
42747 }
42748
42749
42750 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42751 PyObject *resultobj = 0;
42752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42753 wxFont *arg2 = 0 ;
42754 void *argp1 = 0 ;
42755 int res1 = 0 ;
42756 void *argp2 = 0 ;
42757 int res2 = 0 ;
42758 PyObject * obj0 = 0 ;
42759 PyObject * obj1 = 0 ;
42760 char * kwnames[] = {
42761 (char *) "self",(char *) "font", NULL
42762 };
42763
42764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42766 if (!SWIG_IsOK(res1)) {
42767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42768 }
42769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42771 if (!SWIG_IsOK(res2)) {
42772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42773 }
42774 if (!argp2) {
42775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42776 }
42777 arg2 = reinterpret_cast< wxFont * >(argp2);
42778 {
42779 PyThreadState* __tstate = wxPyBeginAllowThreads();
42780 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42781 wxPyEndAllowThreads(__tstate);
42782 if (PyErr_Occurred()) SWIG_fail;
42783 }
42784 resultobj = SWIG_Py_Void();
42785 return resultobj;
42786 fail:
42787 return NULL;
42788 }
42789
42790
42791 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42792 PyObject *resultobj = 0;
42793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42794 wxFont result;
42795 void *argp1 = 0 ;
42796 int res1 = 0 ;
42797 PyObject *swig_obj[1] ;
42798
42799 if (!args) SWIG_fail;
42800 swig_obj[0] = args;
42801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42802 if (!SWIG_IsOK(res1)) {
42803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42804 }
42805 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 result = wxMenuItem_GetFont(arg1);
42809 wxPyEndAllowThreads(__tstate);
42810 if (PyErr_Occurred()) SWIG_fail;
42811 }
42812 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42813 return resultobj;
42814 fail:
42815 return NULL;
42816 }
42817
42818
42819 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42820 PyObject *resultobj = 0;
42821 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42822 wxColour *arg2 = 0 ;
42823 void *argp1 = 0 ;
42824 int res1 = 0 ;
42825 wxColour temp2 ;
42826 PyObject * obj0 = 0 ;
42827 PyObject * obj1 = 0 ;
42828 char * kwnames[] = {
42829 (char *) "self",(char *) "colText", NULL
42830 };
42831
42832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42834 if (!SWIG_IsOK(res1)) {
42835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42836 }
42837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42838 {
42839 arg2 = &temp2;
42840 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42841 }
42842 {
42843 PyThreadState* __tstate = wxPyBeginAllowThreads();
42844 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
42845 wxPyEndAllowThreads(__tstate);
42846 if (PyErr_Occurred()) SWIG_fail;
42847 }
42848 resultobj = SWIG_Py_Void();
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42856 PyObject *resultobj = 0;
42857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42858 wxColour result;
42859 void *argp1 = 0 ;
42860 int res1 = 0 ;
42861 PyObject *swig_obj[1] ;
42862
42863 if (!args) SWIG_fail;
42864 swig_obj[0] = args;
42865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42866 if (!SWIG_IsOK(res1)) {
42867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42868 }
42869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42870 {
42871 PyThreadState* __tstate = wxPyBeginAllowThreads();
42872 result = wxMenuItem_GetTextColour(arg1);
42873 wxPyEndAllowThreads(__tstate);
42874 if (PyErr_Occurred()) SWIG_fail;
42875 }
42876 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42877 return resultobj;
42878 fail:
42879 return NULL;
42880 }
42881
42882
42883 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42884 PyObject *resultobj = 0;
42885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42886 wxColour *arg2 = 0 ;
42887 void *argp1 = 0 ;
42888 int res1 = 0 ;
42889 wxColour temp2 ;
42890 PyObject * obj0 = 0 ;
42891 PyObject * obj1 = 0 ;
42892 char * kwnames[] = {
42893 (char *) "self",(char *) "colBack", NULL
42894 };
42895
42896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
42897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42898 if (!SWIG_IsOK(res1)) {
42899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42900 }
42901 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42902 {
42903 arg2 = &temp2;
42904 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42905 }
42906 {
42907 PyThreadState* __tstate = wxPyBeginAllowThreads();
42908 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 resultobj = SWIG_Py_Void();
42913 return resultobj;
42914 fail:
42915 return NULL;
42916 }
42917
42918
42919 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42920 PyObject *resultobj = 0;
42921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42922 wxColour result;
42923 void *argp1 = 0 ;
42924 int res1 = 0 ;
42925 PyObject *swig_obj[1] ;
42926
42927 if (!args) SWIG_fail;
42928 swig_obj[0] = args;
42929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42930 if (!SWIG_IsOK(res1)) {
42931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42932 }
42933 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42934 {
42935 PyThreadState* __tstate = wxPyBeginAllowThreads();
42936 result = wxMenuItem_GetBackgroundColour(arg1);
42937 wxPyEndAllowThreads(__tstate);
42938 if (PyErr_Occurred()) SWIG_fail;
42939 }
42940 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42941 return resultobj;
42942 fail:
42943 return NULL;
42944 }
42945
42946
42947 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42948 PyObject *resultobj = 0;
42949 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42950 wxBitmap *arg2 = 0 ;
42951 wxBitmap const &arg3_defvalue = wxNullBitmap ;
42952 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
42953 void *argp1 = 0 ;
42954 int res1 = 0 ;
42955 void *argp2 = 0 ;
42956 int res2 = 0 ;
42957 void *argp3 = 0 ;
42958 int res3 = 0 ;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961 PyObject * obj2 = 0 ;
42962 char * kwnames[] = {
42963 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
42964 };
42965
42966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42968 if (!SWIG_IsOK(res1)) {
42969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42970 }
42971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42973 if (!SWIG_IsOK(res2)) {
42974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42975 }
42976 if (!argp2) {
42977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42978 }
42979 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42980 if (obj2) {
42981 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
42982 if (!SWIG_IsOK(res3)) {
42983 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
42984 }
42985 if (!argp3) {
42986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
42987 }
42988 arg3 = reinterpret_cast< wxBitmap * >(argp3);
42989 }
42990 {
42991 PyThreadState* __tstate = wxPyBeginAllowThreads();
42992 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
42993 wxPyEndAllowThreads(__tstate);
42994 if (PyErr_Occurred()) SWIG_fail;
42995 }
42996 resultobj = SWIG_Py_Void();
42997 return resultobj;
42998 fail:
42999 return NULL;
43000 }
43001
43002
43003 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43004 PyObject *resultobj = 0;
43005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43006 wxBitmap *arg2 = 0 ;
43007 void *argp1 = 0 ;
43008 int res1 = 0 ;
43009 void *argp2 = 0 ;
43010 int res2 = 0 ;
43011 PyObject * obj0 = 0 ;
43012 PyObject * obj1 = 0 ;
43013 char * kwnames[] = {
43014 (char *) "self",(char *) "bmpDisabled", NULL
43015 };
43016
43017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43019 if (!SWIG_IsOK(res1)) {
43020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43021 }
43022 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43023 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43024 if (!SWIG_IsOK(res2)) {
43025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43026 }
43027 if (!argp2) {
43028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43029 }
43030 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43031 {
43032 PyThreadState* __tstate = wxPyBeginAllowThreads();
43033 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43034 wxPyEndAllowThreads(__tstate);
43035 if (PyErr_Occurred()) SWIG_fail;
43036 }
43037 resultobj = SWIG_Py_Void();
43038 return resultobj;
43039 fail:
43040 return NULL;
43041 }
43042
43043
43044 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43045 PyObject *resultobj = 0;
43046 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43047 wxBitmap *result = 0 ;
43048 void *argp1 = 0 ;
43049 int res1 = 0 ;
43050 PyObject *swig_obj[1] ;
43051
43052 if (!args) SWIG_fail;
43053 swig_obj[0] = args;
43054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43055 if (!SWIG_IsOK(res1)) {
43056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43057 }
43058 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43059 {
43060 PyThreadState* __tstate = wxPyBeginAllowThreads();
43061 {
43062 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43063 result = (wxBitmap *) &_result_ref;
43064 }
43065 wxPyEndAllowThreads(__tstate);
43066 if (PyErr_Occurred()) SWIG_fail;
43067 }
43068 {
43069 wxBitmap* resultptr = new wxBitmap(*result);
43070 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43071 }
43072 return resultobj;
43073 fail:
43074 return NULL;
43075 }
43076
43077
43078 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43079 PyObject *resultobj = 0;
43080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43081 int arg2 ;
43082 void *argp1 = 0 ;
43083 int res1 = 0 ;
43084 int val2 ;
43085 int ecode2 = 0 ;
43086 PyObject * obj0 = 0 ;
43087 PyObject * obj1 = 0 ;
43088 char * kwnames[] = {
43089 (char *) "self",(char *) "nWidth", NULL
43090 };
43091
43092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43094 if (!SWIG_IsOK(res1)) {
43095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43096 }
43097 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43098 ecode2 = SWIG_AsVal_int(obj1, &val2);
43099 if (!SWIG_IsOK(ecode2)) {
43100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43101 }
43102 arg2 = static_cast< int >(val2);
43103 {
43104 PyThreadState* __tstate = wxPyBeginAllowThreads();
43105 wxMenuItem_SetMarginWidth(arg1,arg2);
43106 wxPyEndAllowThreads(__tstate);
43107 if (PyErr_Occurred()) SWIG_fail;
43108 }
43109 resultobj = SWIG_Py_Void();
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43117 PyObject *resultobj = 0;
43118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43119 int result;
43120 void *argp1 = 0 ;
43121 int res1 = 0 ;
43122 PyObject *swig_obj[1] ;
43123
43124 if (!args) SWIG_fail;
43125 swig_obj[0] = args;
43126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43127 if (!SWIG_IsOK(res1)) {
43128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43129 }
43130 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 result = (int)wxMenuItem_GetMarginWidth(arg1);
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 resultobj = SWIG_From_int(static_cast< int >(result));
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43145 PyObject *resultobj = 0;
43146 int result;
43147
43148 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43149 {
43150 PyThreadState* __tstate = wxPyBeginAllowThreads();
43151 result = (int)wxMenuItem_GetDefaultMarginWidth();
43152 wxPyEndAllowThreads(__tstate);
43153 if (PyErr_Occurred()) SWIG_fail;
43154 }
43155 resultobj = SWIG_From_int(static_cast< int >(result));
43156 return resultobj;
43157 fail:
43158 return NULL;
43159 }
43160
43161
43162 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43163 PyObject *resultobj = 0;
43164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43165 bool result;
43166 void *argp1 = 0 ;
43167 int res1 = 0 ;
43168 PyObject *swig_obj[1] ;
43169
43170 if (!args) SWIG_fail;
43171 swig_obj[0] = args;
43172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43173 if (!SWIG_IsOK(res1)) {
43174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43175 }
43176 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43177 {
43178 PyThreadState* __tstate = wxPyBeginAllowThreads();
43179 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43180 wxPyEndAllowThreads(__tstate);
43181 if (PyErr_Occurred()) SWIG_fail;
43182 }
43183 {
43184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43185 }
43186 return resultobj;
43187 fail:
43188 return NULL;
43189 }
43190
43191
43192 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43193 PyObject *resultobj = 0;
43194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43195 bool arg2 = (bool) true ;
43196 void *argp1 = 0 ;
43197 int res1 = 0 ;
43198 bool val2 ;
43199 int ecode2 = 0 ;
43200 PyObject * obj0 = 0 ;
43201 PyObject * obj1 = 0 ;
43202 char * kwnames[] = {
43203 (char *) "self",(char *) "ownerDrawn", NULL
43204 };
43205
43206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43208 if (!SWIG_IsOK(res1)) {
43209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43210 }
43211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43212 if (obj1) {
43213 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43214 if (!SWIG_IsOK(ecode2)) {
43215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43216 }
43217 arg2 = static_cast< bool >(val2);
43218 }
43219 {
43220 PyThreadState* __tstate = wxPyBeginAllowThreads();
43221 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43222 wxPyEndAllowThreads(__tstate);
43223 if (PyErr_Occurred()) SWIG_fail;
43224 }
43225 resultobj = SWIG_Py_Void();
43226 return resultobj;
43227 fail:
43228 return NULL;
43229 }
43230
43231
43232 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43233 PyObject *resultobj = 0;
43234 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43235 void *argp1 = 0 ;
43236 int res1 = 0 ;
43237 PyObject *swig_obj[1] ;
43238
43239 if (!args) SWIG_fail;
43240 swig_obj[0] = args;
43241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43242 if (!SWIG_IsOK(res1)) {
43243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43244 }
43245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43246 {
43247 PyThreadState* __tstate = wxPyBeginAllowThreads();
43248 wxMenuItem_ResetOwnerDrawn(arg1);
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 resultobj = SWIG_Py_Void();
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43260 PyObject *obj;
43261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43262 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43263 return SWIG_Py_Void();
43264 }
43265
43266 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43267 return SWIG_Python_InitShadowInstance(args);
43268 }
43269
43270 SWIGINTERN int ControlNameStr_set(PyObject *) {
43271 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43272 return 1;
43273 }
43274
43275
43276 SWIGINTERN PyObject *ControlNameStr_get(void) {
43277 PyObject *pyobj = 0;
43278
43279 {
43280 #if wxUSE_UNICODE
43281 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43282 #else
43283 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43284 #endif
43285 }
43286 return pyobj;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43291 PyObject *resultobj = 0;
43292 wxWindow *arg1 = (wxWindow *) 0 ;
43293 int arg2 = (int) -1 ;
43294 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43295 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43296 wxSize const &arg4_defvalue = wxDefaultSize ;
43297 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43298 long arg5 = (long) 0 ;
43299 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43300 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43301 wxString const &arg7_defvalue = wxPyControlNameStr ;
43302 wxString *arg7 = (wxString *) &arg7_defvalue ;
43303 wxControl *result = 0 ;
43304 void *argp1 = 0 ;
43305 int res1 = 0 ;
43306 int val2 ;
43307 int ecode2 = 0 ;
43308 wxPoint temp3 ;
43309 wxSize temp4 ;
43310 long val5 ;
43311 int ecode5 = 0 ;
43312 void *argp6 = 0 ;
43313 int res6 = 0 ;
43314 bool temp7 = false ;
43315 PyObject * obj0 = 0 ;
43316 PyObject * obj1 = 0 ;
43317 PyObject * obj2 = 0 ;
43318 PyObject * obj3 = 0 ;
43319 PyObject * obj4 = 0 ;
43320 PyObject * obj5 = 0 ;
43321 PyObject * obj6 = 0 ;
43322 char * kwnames[] = {
43323 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43324 };
43325
43326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43328 if (!SWIG_IsOK(res1)) {
43329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43330 }
43331 arg1 = reinterpret_cast< wxWindow * >(argp1);
43332 if (obj1) {
43333 ecode2 = SWIG_AsVal_int(obj1, &val2);
43334 if (!SWIG_IsOK(ecode2)) {
43335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43336 }
43337 arg2 = static_cast< int >(val2);
43338 }
43339 if (obj2) {
43340 {
43341 arg3 = &temp3;
43342 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43343 }
43344 }
43345 if (obj3) {
43346 {
43347 arg4 = &temp4;
43348 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43349 }
43350 }
43351 if (obj4) {
43352 ecode5 = SWIG_AsVal_long(obj4, &val5);
43353 if (!SWIG_IsOK(ecode5)) {
43354 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43355 }
43356 arg5 = static_cast< long >(val5);
43357 }
43358 if (obj5) {
43359 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43360 if (!SWIG_IsOK(res6)) {
43361 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43362 }
43363 if (!argp6) {
43364 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43365 }
43366 arg6 = reinterpret_cast< wxValidator * >(argp6);
43367 }
43368 if (obj6) {
43369 {
43370 arg7 = wxString_in_helper(obj6);
43371 if (arg7 == NULL) SWIG_fail;
43372 temp7 = true;
43373 }
43374 }
43375 {
43376 if (!wxPyCheckForApp()) SWIG_fail;
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43383 {
43384 if (temp7)
43385 delete arg7;
43386 }
43387 return resultobj;
43388 fail:
43389 {
43390 if (temp7)
43391 delete arg7;
43392 }
43393 return NULL;
43394 }
43395
43396
43397 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43398 PyObject *resultobj = 0;
43399 wxControl *result = 0 ;
43400
43401 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43402 {
43403 if (!wxPyCheckForApp()) SWIG_fail;
43404 PyThreadState* __tstate = wxPyBeginAllowThreads();
43405 result = (wxControl *)new wxControl();
43406 wxPyEndAllowThreads(__tstate);
43407 if (PyErr_Occurred()) SWIG_fail;
43408 }
43409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43417 PyObject *resultobj = 0;
43418 wxControl *arg1 = (wxControl *) 0 ;
43419 wxWindow *arg2 = (wxWindow *) 0 ;
43420 int arg3 = (int) -1 ;
43421 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43422 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43423 wxSize const &arg5_defvalue = wxDefaultSize ;
43424 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43425 long arg6 = (long) 0 ;
43426 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43427 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43428 wxString const &arg8_defvalue = wxPyControlNameStr ;
43429 wxString *arg8 = (wxString *) &arg8_defvalue ;
43430 bool result;
43431 void *argp1 = 0 ;
43432 int res1 = 0 ;
43433 void *argp2 = 0 ;
43434 int res2 = 0 ;
43435 int val3 ;
43436 int ecode3 = 0 ;
43437 wxPoint temp4 ;
43438 wxSize temp5 ;
43439 long val6 ;
43440 int ecode6 = 0 ;
43441 void *argp7 = 0 ;
43442 int res7 = 0 ;
43443 bool temp8 = false ;
43444 PyObject * obj0 = 0 ;
43445 PyObject * obj1 = 0 ;
43446 PyObject * obj2 = 0 ;
43447 PyObject * obj3 = 0 ;
43448 PyObject * obj4 = 0 ;
43449 PyObject * obj5 = 0 ;
43450 PyObject * obj6 = 0 ;
43451 PyObject * obj7 = 0 ;
43452 char * kwnames[] = {
43453 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43454 };
43455
43456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43458 if (!SWIG_IsOK(res1)) {
43459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43460 }
43461 arg1 = reinterpret_cast< wxControl * >(argp1);
43462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43463 if (!SWIG_IsOK(res2)) {
43464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43465 }
43466 arg2 = reinterpret_cast< wxWindow * >(argp2);
43467 if (obj2) {
43468 ecode3 = SWIG_AsVal_int(obj2, &val3);
43469 if (!SWIG_IsOK(ecode3)) {
43470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43471 }
43472 arg3 = static_cast< int >(val3);
43473 }
43474 if (obj3) {
43475 {
43476 arg4 = &temp4;
43477 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43478 }
43479 }
43480 if (obj4) {
43481 {
43482 arg5 = &temp5;
43483 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43484 }
43485 }
43486 if (obj5) {
43487 ecode6 = SWIG_AsVal_long(obj5, &val6);
43488 if (!SWIG_IsOK(ecode6)) {
43489 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43490 }
43491 arg6 = static_cast< long >(val6);
43492 }
43493 if (obj6) {
43494 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43495 if (!SWIG_IsOK(res7)) {
43496 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43497 }
43498 if (!argp7) {
43499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43500 }
43501 arg7 = reinterpret_cast< wxValidator * >(argp7);
43502 }
43503 if (obj7) {
43504 {
43505 arg8 = wxString_in_helper(obj7);
43506 if (arg8 == NULL) SWIG_fail;
43507 temp8 = true;
43508 }
43509 }
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43513 wxPyEndAllowThreads(__tstate);
43514 if (PyErr_Occurred()) SWIG_fail;
43515 }
43516 {
43517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43518 }
43519 {
43520 if (temp8)
43521 delete arg8;
43522 }
43523 return resultobj;
43524 fail:
43525 {
43526 if (temp8)
43527 delete arg8;
43528 }
43529 return NULL;
43530 }
43531
43532
43533 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43534 PyObject *resultobj = 0;
43535 wxControl *arg1 = (wxControl *) 0 ;
43536 wxCommandEvent *arg2 = 0 ;
43537 void *argp1 = 0 ;
43538 int res1 = 0 ;
43539 void *argp2 = 0 ;
43540 int res2 = 0 ;
43541 PyObject * obj0 = 0 ;
43542 PyObject * obj1 = 0 ;
43543 char * kwnames[] = {
43544 (char *) "self",(char *) "event", NULL
43545 };
43546
43547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43549 if (!SWIG_IsOK(res1)) {
43550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43551 }
43552 arg1 = reinterpret_cast< wxControl * >(argp1);
43553 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43554 if (!SWIG_IsOK(res2)) {
43555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43556 }
43557 if (!argp2) {
43558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43559 }
43560 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43561 {
43562 PyThreadState* __tstate = wxPyBeginAllowThreads();
43563 (arg1)->Command(*arg2);
43564 wxPyEndAllowThreads(__tstate);
43565 if (PyErr_Occurred()) SWIG_fail;
43566 }
43567 resultobj = SWIG_Py_Void();
43568 return resultobj;
43569 fail:
43570 return NULL;
43571 }
43572
43573
43574 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43575 PyObject *resultobj = 0;
43576 wxControl *arg1 = (wxControl *) 0 ;
43577 wxString result;
43578 void *argp1 = 0 ;
43579 int res1 = 0 ;
43580 PyObject *swig_obj[1] ;
43581
43582 if (!args) SWIG_fail;
43583 swig_obj[0] = args;
43584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43585 if (!SWIG_IsOK(res1)) {
43586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43587 }
43588 arg1 = reinterpret_cast< wxControl * >(argp1);
43589 {
43590 PyThreadState* __tstate = wxPyBeginAllowThreads();
43591 result = (arg1)->GetLabel();
43592 wxPyEndAllowThreads(__tstate);
43593 if (PyErr_Occurred()) SWIG_fail;
43594 }
43595 {
43596 #if wxUSE_UNICODE
43597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43598 #else
43599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43600 #endif
43601 }
43602 return resultobj;
43603 fail:
43604 return NULL;
43605 }
43606
43607
43608 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43609 PyObject *resultobj = 0;
43610 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43611 SwigValueWrapper<wxVisualAttributes > result;
43612 int val1 ;
43613 int ecode1 = 0 ;
43614 PyObject * obj0 = 0 ;
43615 char * kwnames[] = {
43616 (char *) "variant", NULL
43617 };
43618
43619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43620 if (obj0) {
43621 ecode1 = SWIG_AsVal_int(obj0, &val1);
43622 if (!SWIG_IsOK(ecode1)) {
43623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43624 }
43625 arg1 = static_cast< wxWindowVariant >(val1);
43626 }
43627 {
43628 if (!wxPyCheckForApp()) SWIG_fail;
43629 PyThreadState* __tstate = wxPyBeginAllowThreads();
43630 result = wxControl::GetClassDefaultAttributes(arg1);
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43635 return resultobj;
43636 fail:
43637 return NULL;
43638 }
43639
43640
43641 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43642 PyObject *obj;
43643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43644 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43645 return SWIG_Py_Void();
43646 }
43647
43648 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43649 return SWIG_Python_InitShadowInstance(args);
43650 }
43651
43652 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43653 PyObject *resultobj = 0;
43654 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43655 wxString *arg2 = 0 ;
43656 PyObject *arg3 = (PyObject *) NULL ;
43657 int result;
43658 void *argp1 = 0 ;
43659 int res1 = 0 ;
43660 bool temp2 = false ;
43661 PyObject * obj0 = 0 ;
43662 PyObject * obj1 = 0 ;
43663 PyObject * obj2 = 0 ;
43664 char * kwnames[] = {
43665 (char *) "self",(char *) "item",(char *) "clientData", NULL
43666 };
43667
43668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43670 if (!SWIG_IsOK(res1)) {
43671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43672 }
43673 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43674 {
43675 arg2 = wxString_in_helper(obj1);
43676 if (arg2 == NULL) SWIG_fail;
43677 temp2 = true;
43678 }
43679 if (obj2) {
43680 arg3 = obj2;
43681 }
43682 {
43683 PyThreadState* __tstate = wxPyBeginAllowThreads();
43684 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43685 wxPyEndAllowThreads(__tstate);
43686 if (PyErr_Occurred()) SWIG_fail;
43687 }
43688 resultobj = SWIG_From_int(static_cast< int >(result));
43689 {
43690 if (temp2)
43691 delete arg2;
43692 }
43693 return resultobj;
43694 fail:
43695 {
43696 if (temp2)
43697 delete arg2;
43698 }
43699 return NULL;
43700 }
43701
43702
43703 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43704 PyObject *resultobj = 0;
43705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43706 wxArrayString *arg2 = 0 ;
43707 void *argp1 = 0 ;
43708 int res1 = 0 ;
43709 bool temp2 = false ;
43710 PyObject * obj0 = 0 ;
43711 PyObject * obj1 = 0 ;
43712 char * kwnames[] = {
43713 (char *) "self",(char *) "strings", NULL
43714 };
43715
43716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43718 if (!SWIG_IsOK(res1)) {
43719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43720 }
43721 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43722 {
43723 if (! PySequence_Check(obj1)) {
43724 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43725 SWIG_fail;
43726 }
43727 arg2 = new wxArrayString;
43728 temp2 = true;
43729 int i, len=PySequence_Length(obj1);
43730 for (i=0; i<len; i++) {
43731 PyObject* item = PySequence_GetItem(obj1, i);
43732 wxString* s = wxString_in_helper(item);
43733 if (PyErr_Occurred()) SWIG_fail;
43734 arg2->Add(*s);
43735 delete s;
43736 Py_DECREF(item);
43737 }
43738 }
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 (arg1)->Append((wxArrayString const &)*arg2);
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_Py_Void();
43746 {
43747 if (temp2) delete arg2;
43748 }
43749 return resultobj;
43750 fail:
43751 {
43752 if (temp2) delete arg2;
43753 }
43754 return NULL;
43755 }
43756
43757
43758 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43759 PyObject *resultobj = 0;
43760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43761 wxString *arg2 = 0 ;
43762 int arg3 ;
43763 PyObject *arg4 = (PyObject *) NULL ;
43764 int result;
43765 void *argp1 = 0 ;
43766 int res1 = 0 ;
43767 bool temp2 = false ;
43768 int val3 ;
43769 int ecode3 = 0 ;
43770 PyObject * obj0 = 0 ;
43771 PyObject * obj1 = 0 ;
43772 PyObject * obj2 = 0 ;
43773 PyObject * obj3 = 0 ;
43774 char * kwnames[] = {
43775 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43776 };
43777
43778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43780 if (!SWIG_IsOK(res1)) {
43781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43782 }
43783 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43784 {
43785 arg2 = wxString_in_helper(obj1);
43786 if (arg2 == NULL) SWIG_fail;
43787 temp2 = true;
43788 }
43789 ecode3 = SWIG_AsVal_int(obj2, &val3);
43790 if (!SWIG_IsOK(ecode3)) {
43791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
43792 }
43793 arg3 = static_cast< int >(val3);
43794 if (obj3) {
43795 arg4 = obj3;
43796 }
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43800 wxPyEndAllowThreads(__tstate);
43801 if (PyErr_Occurred()) SWIG_fail;
43802 }
43803 resultobj = SWIG_From_int(static_cast< int >(result));
43804 {
43805 if (temp2)
43806 delete arg2;
43807 }
43808 return resultobj;
43809 fail:
43810 {
43811 if (temp2)
43812 delete arg2;
43813 }
43814 return NULL;
43815 }
43816
43817
43818 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43819 PyObject *resultobj = 0;
43820 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43821 void *argp1 = 0 ;
43822 int res1 = 0 ;
43823 PyObject *swig_obj[1] ;
43824
43825 if (!args) SWIG_fail;
43826 swig_obj[0] = args;
43827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43828 if (!SWIG_IsOK(res1)) {
43829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43830 }
43831 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43832 {
43833 PyThreadState* __tstate = wxPyBeginAllowThreads();
43834 (arg1)->Clear();
43835 wxPyEndAllowThreads(__tstate);
43836 if (PyErr_Occurred()) SWIG_fail;
43837 }
43838 resultobj = SWIG_Py_Void();
43839 return resultobj;
43840 fail:
43841 return NULL;
43842 }
43843
43844
43845 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43846 PyObject *resultobj = 0;
43847 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43848 int arg2 ;
43849 void *argp1 = 0 ;
43850 int res1 = 0 ;
43851 int val2 ;
43852 int ecode2 = 0 ;
43853 PyObject * obj0 = 0 ;
43854 PyObject * obj1 = 0 ;
43855 char * kwnames[] = {
43856 (char *) "self",(char *) "n", NULL
43857 };
43858
43859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43861 if (!SWIG_IsOK(res1)) {
43862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43863 }
43864 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43865 ecode2 = SWIG_AsVal_int(obj1, &val2);
43866 if (!SWIG_IsOK(ecode2)) {
43867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
43868 }
43869 arg2 = static_cast< int >(val2);
43870 {
43871 PyThreadState* __tstate = wxPyBeginAllowThreads();
43872 (arg1)->Delete(arg2);
43873 wxPyEndAllowThreads(__tstate);
43874 if (PyErr_Occurred()) SWIG_fail;
43875 }
43876 resultobj = SWIG_Py_Void();
43877 return resultobj;
43878 fail:
43879 return NULL;
43880 }
43881
43882
43883 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43884 PyObject *resultobj = 0;
43885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43886 int arg2 ;
43887 PyObject *result = 0 ;
43888 void *argp1 = 0 ;
43889 int res1 = 0 ;
43890 int val2 ;
43891 int ecode2 = 0 ;
43892 PyObject * obj0 = 0 ;
43893 PyObject * obj1 = 0 ;
43894 char * kwnames[] = {
43895 (char *) "self",(char *) "n", NULL
43896 };
43897
43898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
43899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43900 if (!SWIG_IsOK(res1)) {
43901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43902 }
43903 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43904 ecode2 = SWIG_AsVal_int(obj1, &val2);
43905 if (!SWIG_IsOK(ecode2)) {
43906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
43907 }
43908 arg2 = static_cast< int >(val2);
43909 {
43910 PyThreadState* __tstate = wxPyBeginAllowThreads();
43911 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
43912 wxPyEndAllowThreads(__tstate);
43913 if (PyErr_Occurred()) SWIG_fail;
43914 }
43915 resultobj = result;
43916 return resultobj;
43917 fail:
43918 return NULL;
43919 }
43920
43921
43922 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43923 PyObject *resultobj = 0;
43924 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43925 int arg2 ;
43926 PyObject *arg3 = (PyObject *) 0 ;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 int val2 ;
43930 int ecode2 = 0 ;
43931 PyObject * obj0 = 0 ;
43932 PyObject * obj1 = 0 ;
43933 PyObject * obj2 = 0 ;
43934 char * kwnames[] = {
43935 (char *) "self",(char *) "n",(char *) "clientData", NULL
43936 };
43937
43938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43940 if (!SWIG_IsOK(res1)) {
43941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43942 }
43943 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43944 ecode2 = SWIG_AsVal_int(obj1, &val2);
43945 if (!SWIG_IsOK(ecode2)) {
43946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
43947 }
43948 arg2 = static_cast< int >(val2);
43949 arg3 = obj2;
43950 {
43951 PyThreadState* __tstate = wxPyBeginAllowThreads();
43952 wxItemContainer_SetClientData(arg1,arg2,arg3);
43953 wxPyEndAllowThreads(__tstate);
43954 if (PyErr_Occurred()) SWIG_fail;
43955 }
43956 resultobj = SWIG_Py_Void();
43957 return resultobj;
43958 fail:
43959 return NULL;
43960 }
43961
43962
43963 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43964 PyObject *resultobj = 0;
43965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43966 int result;
43967 void *argp1 = 0 ;
43968 int res1 = 0 ;
43969 PyObject *swig_obj[1] ;
43970
43971 if (!args) SWIG_fail;
43972 swig_obj[0] = args;
43973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43974 if (!SWIG_IsOK(res1)) {
43975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
43976 }
43977 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 result = (int)((wxItemContainer const *)arg1)->GetCount();
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 resultobj = SWIG_From_int(static_cast< int >(result));
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43992 PyObject *resultobj = 0;
43993 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43994 bool result;
43995 void *argp1 = 0 ;
43996 int res1 = 0 ;
43997 PyObject *swig_obj[1] ;
43998
43999 if (!args) SWIG_fail;
44000 swig_obj[0] = args;
44001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44002 if (!SWIG_IsOK(res1)) {
44003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44004 }
44005 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44006 {
44007 PyThreadState* __tstate = wxPyBeginAllowThreads();
44008 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44009 wxPyEndAllowThreads(__tstate);
44010 if (PyErr_Occurred()) SWIG_fail;
44011 }
44012 {
44013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44014 }
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44022 PyObject *resultobj = 0;
44023 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44024 int arg2 ;
44025 wxString result;
44026 void *argp1 = 0 ;
44027 int res1 = 0 ;
44028 int val2 ;
44029 int ecode2 = 0 ;
44030 PyObject * obj0 = 0 ;
44031 PyObject * obj1 = 0 ;
44032 char * kwnames[] = {
44033 (char *) "self",(char *) "n", NULL
44034 };
44035
44036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44038 if (!SWIG_IsOK(res1)) {
44039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44040 }
44041 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44042 ecode2 = SWIG_AsVal_int(obj1, &val2);
44043 if (!SWIG_IsOK(ecode2)) {
44044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
44045 }
44046 arg2 = static_cast< int >(val2);
44047 {
44048 PyThreadState* __tstate = wxPyBeginAllowThreads();
44049 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44050 wxPyEndAllowThreads(__tstate);
44051 if (PyErr_Occurred()) SWIG_fail;
44052 }
44053 {
44054 #if wxUSE_UNICODE
44055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44056 #else
44057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44058 #endif
44059 }
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44067 PyObject *resultobj = 0;
44068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44069 wxArrayString result;
44070 void *argp1 = 0 ;
44071 int res1 = 0 ;
44072 PyObject *swig_obj[1] ;
44073
44074 if (!args) SWIG_fail;
44075 swig_obj[0] = args;
44076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44077 if (!SWIG_IsOK(res1)) {
44078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44079 }
44080 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44081 {
44082 PyThreadState* __tstate = wxPyBeginAllowThreads();
44083 result = ((wxItemContainer const *)arg1)->GetStrings();
44084 wxPyEndAllowThreads(__tstate);
44085 if (PyErr_Occurred()) SWIG_fail;
44086 }
44087 {
44088 resultobj = wxArrayString2PyList_helper(result);
44089 }
44090 return resultobj;
44091 fail:
44092 return NULL;
44093 }
44094
44095
44096 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44097 PyObject *resultobj = 0;
44098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44099 int arg2 ;
44100 wxString *arg3 = 0 ;
44101 void *argp1 = 0 ;
44102 int res1 = 0 ;
44103 int val2 ;
44104 int ecode2 = 0 ;
44105 bool temp3 = false ;
44106 PyObject * obj0 = 0 ;
44107 PyObject * obj1 = 0 ;
44108 PyObject * obj2 = 0 ;
44109 char * kwnames[] = {
44110 (char *) "self",(char *) "n",(char *) "s", NULL
44111 };
44112
44113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44115 if (!SWIG_IsOK(res1)) {
44116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44117 }
44118 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44119 ecode2 = SWIG_AsVal_int(obj1, &val2);
44120 if (!SWIG_IsOK(ecode2)) {
44121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
44122 }
44123 arg2 = static_cast< int >(val2);
44124 {
44125 arg3 = wxString_in_helper(obj2);
44126 if (arg3 == NULL) SWIG_fail;
44127 temp3 = true;
44128 }
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 (arg1)->SetString(arg2,(wxString const &)*arg3);
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 resultobj = SWIG_Py_Void();
44136 {
44137 if (temp3)
44138 delete arg3;
44139 }
44140 return resultobj;
44141 fail:
44142 {
44143 if (temp3)
44144 delete arg3;
44145 }
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44153 wxString *arg2 = 0 ;
44154 int result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 bool temp2 = false ;
44158 PyObject * obj0 = 0 ;
44159 PyObject * obj1 = 0 ;
44160 char * kwnames[] = {
44161 (char *) "self",(char *) "s", NULL
44162 };
44163
44164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44166 if (!SWIG_IsOK(res1)) {
44167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44168 }
44169 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44170 {
44171 arg2 = wxString_in_helper(obj1);
44172 if (arg2 == NULL) SWIG_fail;
44173 temp2 = true;
44174 }
44175 {
44176 PyThreadState* __tstate = wxPyBeginAllowThreads();
44177 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44178 wxPyEndAllowThreads(__tstate);
44179 if (PyErr_Occurred()) SWIG_fail;
44180 }
44181 resultobj = SWIG_From_int(static_cast< int >(result));
44182 {
44183 if (temp2)
44184 delete arg2;
44185 }
44186 return resultobj;
44187 fail:
44188 {
44189 if (temp2)
44190 delete arg2;
44191 }
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj = 0;
44198 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44199 int arg2 ;
44200 void *argp1 = 0 ;
44201 int res1 = 0 ;
44202 int val2 ;
44203 int ecode2 = 0 ;
44204 PyObject * obj0 = 0 ;
44205 PyObject * obj1 = 0 ;
44206 char * kwnames[] = {
44207 (char *) "self",(char *) "n", NULL
44208 };
44209
44210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44212 if (!SWIG_IsOK(res1)) {
44213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44214 }
44215 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44216 ecode2 = SWIG_AsVal_int(obj1, &val2);
44217 if (!SWIG_IsOK(ecode2)) {
44218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44219 }
44220 arg2 = static_cast< int >(val2);
44221 {
44222 PyThreadState* __tstate = wxPyBeginAllowThreads();
44223 (arg1)->SetSelection(arg2);
44224 wxPyEndAllowThreads(__tstate);
44225 if (PyErr_Occurred()) SWIG_fail;
44226 }
44227 resultobj = SWIG_Py_Void();
44228 return resultobj;
44229 fail:
44230 return NULL;
44231 }
44232
44233
44234 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44235 PyObject *resultobj = 0;
44236 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44237 int result;
44238 void *argp1 = 0 ;
44239 int res1 = 0 ;
44240 PyObject *swig_obj[1] ;
44241
44242 if (!args) SWIG_fail;
44243 swig_obj[0] = args;
44244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44245 if (!SWIG_IsOK(res1)) {
44246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44247 }
44248 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44249 {
44250 PyThreadState* __tstate = wxPyBeginAllowThreads();
44251 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44252 wxPyEndAllowThreads(__tstate);
44253 if (PyErr_Occurred()) SWIG_fail;
44254 }
44255 resultobj = SWIG_From_int(static_cast< int >(result));
44256 return resultobj;
44257 fail:
44258 return NULL;
44259 }
44260
44261
44262 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44263 PyObject *resultobj = 0;
44264 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44265 wxString *arg2 = 0 ;
44266 bool result;
44267 void *argp1 = 0 ;
44268 int res1 = 0 ;
44269 bool temp2 = false ;
44270 PyObject * obj0 = 0 ;
44271 PyObject * obj1 = 0 ;
44272 char * kwnames[] = {
44273 (char *) "self",(char *) "s", NULL
44274 };
44275
44276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44278 if (!SWIG_IsOK(res1)) {
44279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44280 }
44281 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44282 {
44283 arg2 = wxString_in_helper(obj1);
44284 if (arg2 == NULL) SWIG_fail;
44285 temp2 = true;
44286 }
44287 {
44288 PyThreadState* __tstate = wxPyBeginAllowThreads();
44289 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44290 wxPyEndAllowThreads(__tstate);
44291 if (PyErr_Occurred()) SWIG_fail;
44292 }
44293 {
44294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44295 }
44296 {
44297 if (temp2)
44298 delete arg2;
44299 }
44300 return resultobj;
44301 fail:
44302 {
44303 if (temp2)
44304 delete arg2;
44305 }
44306 return NULL;
44307 }
44308
44309
44310 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44311 PyObject *resultobj = 0;
44312 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44313 wxString result;
44314 void *argp1 = 0 ;
44315 int res1 = 0 ;
44316 PyObject *swig_obj[1] ;
44317
44318 if (!args) SWIG_fail;
44319 swig_obj[0] = args;
44320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44321 if (!SWIG_IsOK(res1)) {
44322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44323 }
44324 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44325 {
44326 PyThreadState* __tstate = wxPyBeginAllowThreads();
44327 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44328 wxPyEndAllowThreads(__tstate);
44329 if (PyErr_Occurred()) SWIG_fail;
44330 }
44331 {
44332 #if wxUSE_UNICODE
44333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44334 #else
44335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44336 #endif
44337 }
44338 return resultobj;
44339 fail:
44340 return NULL;
44341 }
44342
44343
44344 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44345 PyObject *resultobj = 0;
44346 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44347 int arg2 ;
44348 void *argp1 = 0 ;
44349 int res1 = 0 ;
44350 int val2 ;
44351 int ecode2 = 0 ;
44352 PyObject * obj0 = 0 ;
44353 PyObject * obj1 = 0 ;
44354 char * kwnames[] = {
44355 (char *) "self",(char *) "n", NULL
44356 };
44357
44358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44360 if (!SWIG_IsOK(res1)) {
44361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44362 }
44363 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44364 ecode2 = SWIG_AsVal_int(obj1, &val2);
44365 if (!SWIG_IsOK(ecode2)) {
44366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44367 }
44368 arg2 = static_cast< int >(val2);
44369 {
44370 PyThreadState* __tstate = wxPyBeginAllowThreads();
44371 (arg1)->Select(arg2);
44372 wxPyEndAllowThreads(__tstate);
44373 if (PyErr_Occurred()) SWIG_fail;
44374 }
44375 resultobj = SWIG_Py_Void();
44376 return resultobj;
44377 fail:
44378 return NULL;
44379 }
44380
44381
44382 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44383 PyObject *obj;
44384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44385 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44386 return SWIG_Py_Void();
44387 }
44388
44389 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44390 PyObject *obj;
44391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44392 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44393 return SWIG_Py_Void();
44394 }
44395
44396 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44397 PyObject *resultobj = 0;
44398 wxSizerItem *result = 0 ;
44399
44400 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44401 {
44402 PyThreadState* __tstate = wxPyBeginAllowThreads();
44403 result = (wxSizerItem *)new wxSizerItem();
44404 wxPyEndAllowThreads(__tstate);
44405 if (PyErr_Occurred()) SWIG_fail;
44406 }
44407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44408 return resultobj;
44409 fail:
44410 return NULL;
44411 }
44412
44413
44414 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44415 PyObject *resultobj = 0;
44416 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44417 void *argp1 = 0 ;
44418 int res1 = 0 ;
44419 PyObject *swig_obj[1] ;
44420
44421 if (!args) SWIG_fail;
44422 swig_obj[0] = args;
44423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44424 if (!SWIG_IsOK(res1)) {
44425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44426 }
44427 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 delete arg1;
44431
44432 wxPyEndAllowThreads(__tstate);
44433 if (PyErr_Occurred()) SWIG_fail;
44434 }
44435 resultobj = SWIG_Py_Void();
44436 return resultobj;
44437 fail:
44438 return NULL;
44439 }
44440
44441
44442 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44443 PyObject *resultobj = 0;
44444 wxWindow *arg1 = (wxWindow *) 0 ;
44445 int arg2 ;
44446 int arg3 ;
44447 int arg4 ;
44448 PyObject *arg5 = (PyObject *) NULL ;
44449 wxSizerItem *result = 0 ;
44450 void *argp1 = 0 ;
44451 int res1 = 0 ;
44452 int val2 ;
44453 int ecode2 = 0 ;
44454 int val3 ;
44455 int ecode3 = 0 ;
44456 int val4 ;
44457 int ecode4 = 0 ;
44458 PyObject * obj0 = 0 ;
44459 PyObject * obj1 = 0 ;
44460 PyObject * obj2 = 0 ;
44461 PyObject * obj3 = 0 ;
44462 PyObject * obj4 = 0 ;
44463 char * kwnames[] = {
44464 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44465 };
44466
44467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44469 if (!SWIG_IsOK(res1)) {
44470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44471 }
44472 arg1 = reinterpret_cast< wxWindow * >(argp1);
44473 ecode2 = SWIG_AsVal_int(obj1, &val2);
44474 if (!SWIG_IsOK(ecode2)) {
44475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44476 }
44477 arg2 = static_cast< int >(val2);
44478 ecode3 = SWIG_AsVal_int(obj2, &val3);
44479 if (!SWIG_IsOK(ecode3)) {
44480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44481 }
44482 arg3 = static_cast< int >(val3);
44483 ecode4 = SWIG_AsVal_int(obj3, &val4);
44484 if (!SWIG_IsOK(ecode4)) {
44485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44486 }
44487 arg4 = static_cast< int >(val4);
44488 if (obj4) {
44489 arg5 = obj4;
44490 }
44491 {
44492 PyThreadState* __tstate = wxPyBeginAllowThreads();
44493 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44494 wxPyEndAllowThreads(__tstate);
44495 if (PyErr_Occurred()) SWIG_fail;
44496 }
44497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44498 return resultobj;
44499 fail:
44500 return NULL;
44501 }
44502
44503
44504 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44505 PyObject *resultobj = 0;
44506 int arg1 ;
44507 int arg2 ;
44508 int arg3 ;
44509 int arg4 ;
44510 int arg5 ;
44511 PyObject *arg6 = (PyObject *) NULL ;
44512 wxSizerItem *result = 0 ;
44513 int val1 ;
44514 int ecode1 = 0 ;
44515 int val2 ;
44516 int ecode2 = 0 ;
44517 int val3 ;
44518 int ecode3 = 0 ;
44519 int val4 ;
44520 int ecode4 = 0 ;
44521 int val5 ;
44522 int ecode5 = 0 ;
44523 PyObject * obj0 = 0 ;
44524 PyObject * obj1 = 0 ;
44525 PyObject * obj2 = 0 ;
44526 PyObject * obj3 = 0 ;
44527 PyObject * obj4 = 0 ;
44528 PyObject * obj5 = 0 ;
44529 char * kwnames[] = {
44530 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44531 };
44532
44533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44534 ecode1 = SWIG_AsVal_int(obj0, &val1);
44535 if (!SWIG_IsOK(ecode1)) {
44536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44537 }
44538 arg1 = static_cast< int >(val1);
44539 ecode2 = SWIG_AsVal_int(obj1, &val2);
44540 if (!SWIG_IsOK(ecode2)) {
44541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44542 }
44543 arg2 = static_cast< int >(val2);
44544 ecode3 = SWIG_AsVal_int(obj2, &val3);
44545 if (!SWIG_IsOK(ecode3)) {
44546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44547 }
44548 arg3 = static_cast< int >(val3);
44549 ecode4 = SWIG_AsVal_int(obj3, &val4);
44550 if (!SWIG_IsOK(ecode4)) {
44551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44552 }
44553 arg4 = static_cast< int >(val4);
44554 ecode5 = SWIG_AsVal_int(obj4, &val5);
44555 if (!SWIG_IsOK(ecode5)) {
44556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44557 }
44558 arg5 = static_cast< int >(val5);
44559 if (obj5) {
44560 arg6 = obj5;
44561 }
44562 {
44563 PyThreadState* __tstate = wxPyBeginAllowThreads();
44564 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44565 wxPyEndAllowThreads(__tstate);
44566 if (PyErr_Occurred()) SWIG_fail;
44567 }
44568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44569 return resultobj;
44570 fail:
44571 return NULL;
44572 }
44573
44574
44575 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44576 PyObject *resultobj = 0;
44577 wxSizer *arg1 = (wxSizer *) 0 ;
44578 int arg2 ;
44579 int arg3 ;
44580 int arg4 ;
44581 PyObject *arg5 = (PyObject *) NULL ;
44582 wxSizerItem *result = 0 ;
44583 int res1 = 0 ;
44584 int val2 ;
44585 int ecode2 = 0 ;
44586 int val3 ;
44587 int ecode3 = 0 ;
44588 int val4 ;
44589 int ecode4 = 0 ;
44590 PyObject * obj0 = 0 ;
44591 PyObject * obj1 = 0 ;
44592 PyObject * obj2 = 0 ;
44593 PyObject * obj3 = 0 ;
44594 PyObject * obj4 = 0 ;
44595 char * kwnames[] = {
44596 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44597 };
44598
44599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44600 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44601 if (!SWIG_IsOK(res1)) {
44602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44603 }
44604 ecode2 = SWIG_AsVal_int(obj1, &val2);
44605 if (!SWIG_IsOK(ecode2)) {
44606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44607 }
44608 arg2 = static_cast< int >(val2);
44609 ecode3 = SWIG_AsVal_int(obj2, &val3);
44610 if (!SWIG_IsOK(ecode3)) {
44611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44612 }
44613 arg3 = static_cast< int >(val3);
44614 ecode4 = SWIG_AsVal_int(obj3, &val4);
44615 if (!SWIG_IsOK(ecode4)) {
44616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44617 }
44618 arg4 = static_cast< int >(val4);
44619 if (obj4) {
44620 arg5 = obj4;
44621 }
44622 {
44623 PyThreadState* __tstate = wxPyBeginAllowThreads();
44624 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44636 PyObject *resultobj = 0;
44637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44638 void *argp1 = 0 ;
44639 int res1 = 0 ;
44640 PyObject *swig_obj[1] ;
44641
44642 if (!args) SWIG_fail;
44643 swig_obj[0] = args;
44644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44645 if (!SWIG_IsOK(res1)) {
44646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44647 }
44648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44649 {
44650 PyThreadState* __tstate = wxPyBeginAllowThreads();
44651 (arg1)->DeleteWindows();
44652 wxPyEndAllowThreads(__tstate);
44653 if (PyErr_Occurred()) SWIG_fail;
44654 }
44655 resultobj = SWIG_Py_Void();
44656 return resultobj;
44657 fail:
44658 return NULL;
44659 }
44660
44661
44662 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44663 PyObject *resultobj = 0;
44664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44665 void *argp1 = 0 ;
44666 int res1 = 0 ;
44667 PyObject *swig_obj[1] ;
44668
44669 if (!args) SWIG_fail;
44670 swig_obj[0] = args;
44671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44672 if (!SWIG_IsOK(res1)) {
44673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44674 }
44675 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 (arg1)->DetachSizer();
44679 wxPyEndAllowThreads(__tstate);
44680 if (PyErr_Occurred()) SWIG_fail;
44681 }
44682 resultobj = SWIG_Py_Void();
44683 return resultobj;
44684 fail:
44685 return NULL;
44686 }
44687
44688
44689 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44690 PyObject *resultobj = 0;
44691 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44692 wxSize result;
44693 void *argp1 = 0 ;
44694 int res1 = 0 ;
44695 PyObject *swig_obj[1] ;
44696
44697 if (!args) SWIG_fail;
44698 swig_obj[0] = args;
44699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44702 }
44703 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44704 {
44705 PyThreadState* __tstate = wxPyBeginAllowThreads();
44706 result = (arg1)->GetSize();
44707 wxPyEndAllowThreads(__tstate);
44708 if (PyErr_Occurred()) SWIG_fail;
44709 }
44710 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44711 return resultobj;
44712 fail:
44713 return NULL;
44714 }
44715
44716
44717 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44718 PyObject *resultobj = 0;
44719 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44720 wxSize result;
44721 void *argp1 = 0 ;
44722 int res1 = 0 ;
44723 PyObject *swig_obj[1] ;
44724
44725 if (!args) SWIG_fail;
44726 swig_obj[0] = args;
44727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44728 if (!SWIG_IsOK(res1)) {
44729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44730 }
44731 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44732 {
44733 PyThreadState* __tstate = wxPyBeginAllowThreads();
44734 result = (arg1)->CalcMin();
44735 wxPyEndAllowThreads(__tstate);
44736 if (PyErr_Occurred()) SWIG_fail;
44737 }
44738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44739 return resultobj;
44740 fail:
44741 return NULL;
44742 }
44743
44744
44745 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44746 PyObject *resultobj = 0;
44747 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44748 wxPoint *arg2 = 0 ;
44749 wxSize *arg3 = 0 ;
44750 void *argp1 = 0 ;
44751 int res1 = 0 ;
44752 wxPoint temp2 ;
44753 wxSize temp3 ;
44754 PyObject * obj0 = 0 ;
44755 PyObject * obj1 = 0 ;
44756 PyObject * obj2 = 0 ;
44757 char * kwnames[] = {
44758 (char *) "self",(char *) "pos",(char *) "size", NULL
44759 };
44760
44761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44763 if (!SWIG_IsOK(res1)) {
44764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44765 }
44766 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44767 {
44768 arg2 = &temp2;
44769 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44770 }
44771 {
44772 arg3 = &temp3;
44773 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44774 }
44775 {
44776 PyThreadState* __tstate = wxPyBeginAllowThreads();
44777 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 resultobj = SWIG_Py_Void();
44782 return resultobj;
44783 fail:
44784 return NULL;
44785 }
44786
44787
44788 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44789 PyObject *resultobj = 0;
44790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44791 wxSize result;
44792 void *argp1 = 0 ;
44793 int res1 = 0 ;
44794 PyObject *swig_obj[1] ;
44795
44796 if (!args) SWIG_fail;
44797 swig_obj[0] = args;
44798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44799 if (!SWIG_IsOK(res1)) {
44800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44801 }
44802 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44803 {
44804 PyThreadState* __tstate = wxPyBeginAllowThreads();
44805 result = (arg1)->GetMinSize();
44806 wxPyEndAllowThreads(__tstate);
44807 if (PyErr_Occurred()) SWIG_fail;
44808 }
44809 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44810 return resultobj;
44811 fail:
44812 return NULL;
44813 }
44814
44815
44816 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44817 PyObject *resultobj = 0;
44818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44819 wxSize result;
44820 void *argp1 = 0 ;
44821 int res1 = 0 ;
44822 PyObject *swig_obj[1] ;
44823
44824 if (!args) SWIG_fail;
44825 swig_obj[0] = args;
44826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44827 if (!SWIG_IsOK(res1)) {
44828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44829 }
44830 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44831 {
44832 PyThreadState* __tstate = wxPyBeginAllowThreads();
44833 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44834 wxPyEndAllowThreads(__tstate);
44835 if (PyErr_Occurred()) SWIG_fail;
44836 }
44837 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44845 PyObject *resultobj = 0;
44846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44847 int arg2 ;
44848 int arg3 ;
44849 void *argp1 = 0 ;
44850 int res1 = 0 ;
44851 int val2 ;
44852 int ecode2 = 0 ;
44853 int val3 ;
44854 int ecode3 = 0 ;
44855 PyObject * obj0 = 0 ;
44856 PyObject * obj1 = 0 ;
44857 PyObject * obj2 = 0 ;
44858 char * kwnames[] = {
44859 (char *) "self",(char *) "x",(char *) "y", NULL
44860 };
44861
44862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44864 if (!SWIG_IsOK(res1)) {
44865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44866 }
44867 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44868 ecode2 = SWIG_AsVal_int(obj1, &val2);
44869 if (!SWIG_IsOK(ecode2)) {
44870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
44871 }
44872 arg2 = static_cast< int >(val2);
44873 ecode3 = SWIG_AsVal_int(obj2, &val3);
44874 if (!SWIG_IsOK(ecode3)) {
44875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
44876 }
44877 arg3 = static_cast< int >(val3);
44878 {
44879 PyThreadState* __tstate = wxPyBeginAllowThreads();
44880 (arg1)->SetInitSize(arg2,arg3);
44881 wxPyEndAllowThreads(__tstate);
44882 if (PyErr_Occurred()) SWIG_fail;
44883 }
44884 resultobj = SWIG_Py_Void();
44885 return resultobj;
44886 fail:
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj = 0;
44893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44894 int arg2 ;
44895 int arg3 ;
44896 void *argp1 = 0 ;
44897 int res1 = 0 ;
44898 int val2 ;
44899 int ecode2 = 0 ;
44900 int val3 ;
44901 int ecode3 = 0 ;
44902 PyObject * obj0 = 0 ;
44903 PyObject * obj1 = 0 ;
44904 PyObject * obj2 = 0 ;
44905 char * kwnames[] = {
44906 (char *) "self",(char *) "width",(char *) "height", NULL
44907 };
44908
44909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44911 if (!SWIG_IsOK(res1)) {
44912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44913 }
44914 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44915 ecode2 = SWIG_AsVal_int(obj1, &val2);
44916 if (!SWIG_IsOK(ecode2)) {
44917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
44918 }
44919 arg2 = static_cast< int >(val2);
44920 ecode3 = SWIG_AsVal_int(obj2, &val3);
44921 if (!SWIG_IsOK(ecode3)) {
44922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
44923 }
44924 arg3 = static_cast< int >(val3);
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 (arg1)->SetRatio(arg2,arg3);
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 resultobj = SWIG_Py_Void();
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj = 0;
44940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44941 wxSize *arg2 = 0 ;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 wxSize temp2 ;
44945 PyObject * obj0 = 0 ;
44946 PyObject * obj1 = 0 ;
44947 char * kwnames[] = {
44948 (char *) "self",(char *) "size", NULL
44949 };
44950
44951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
44952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44953 if (!SWIG_IsOK(res1)) {
44954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44955 }
44956 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44957 {
44958 arg2 = &temp2;
44959 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44960 }
44961 {
44962 PyThreadState* __tstate = wxPyBeginAllowThreads();
44963 (arg1)->SetRatio((wxSize const &)*arg2);
44964 wxPyEndAllowThreads(__tstate);
44965 if (PyErr_Occurred()) SWIG_fail;
44966 }
44967 resultobj = SWIG_Py_Void();
44968 return resultobj;
44969 fail:
44970 return NULL;
44971 }
44972
44973
44974 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44975 PyObject *resultobj = 0;
44976 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44977 float arg2 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 float val2 ;
44981 int ecode2 = 0 ;
44982 PyObject * obj0 = 0 ;
44983 PyObject * obj1 = 0 ;
44984 char * kwnames[] = {
44985 (char *) "self",(char *) "ratio", NULL
44986 };
44987
44988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
44989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44990 if (!SWIG_IsOK(res1)) {
44991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44992 }
44993 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44994 ecode2 = SWIG_AsVal_float(obj1, &val2);
44995 if (!SWIG_IsOK(ecode2)) {
44996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
44997 }
44998 arg2 = static_cast< float >(val2);
44999 {
45000 PyThreadState* __tstate = wxPyBeginAllowThreads();
45001 (arg1)->SetRatio(arg2);
45002 wxPyEndAllowThreads(__tstate);
45003 if (PyErr_Occurred()) SWIG_fail;
45004 }
45005 resultobj = SWIG_Py_Void();
45006 return resultobj;
45007 fail:
45008 return NULL;
45009 }
45010
45011
45012 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45013 PyObject *resultobj = 0;
45014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45015 float result;
45016 void *argp1 = 0 ;
45017 int res1 = 0 ;
45018 PyObject *swig_obj[1] ;
45019
45020 if (!args) SWIG_fail;
45021 swig_obj[0] = args;
45022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45023 if (!SWIG_IsOK(res1)) {
45024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45025 }
45026 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45027 {
45028 PyThreadState* __tstate = wxPyBeginAllowThreads();
45029 result = (float)(arg1)->GetRatio();
45030 wxPyEndAllowThreads(__tstate);
45031 if (PyErr_Occurred()) SWIG_fail;
45032 }
45033 resultobj = SWIG_From_float(static_cast< float >(result));
45034 return resultobj;
45035 fail:
45036 return NULL;
45037 }
45038
45039
45040 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45041 PyObject *resultobj = 0;
45042 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45043 wxRect result;
45044 void *argp1 = 0 ;
45045 int res1 = 0 ;
45046 PyObject *swig_obj[1] ;
45047
45048 if (!args) SWIG_fail;
45049 swig_obj[0] = args;
45050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45051 if (!SWIG_IsOK(res1)) {
45052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45053 }
45054 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45055 {
45056 PyThreadState* __tstate = wxPyBeginAllowThreads();
45057 result = (arg1)->GetRect();
45058 wxPyEndAllowThreads(__tstate);
45059 if (PyErr_Occurred()) SWIG_fail;
45060 }
45061 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45062 return resultobj;
45063 fail:
45064 return NULL;
45065 }
45066
45067
45068 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45069 PyObject *resultobj = 0;
45070 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45071 bool result;
45072 void *argp1 = 0 ;
45073 int res1 = 0 ;
45074 PyObject *swig_obj[1] ;
45075
45076 if (!args) SWIG_fail;
45077 swig_obj[0] = args;
45078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45079 if (!SWIG_IsOK(res1)) {
45080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45081 }
45082 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45083 {
45084 PyThreadState* __tstate = wxPyBeginAllowThreads();
45085 result = (bool)(arg1)->IsWindow();
45086 wxPyEndAllowThreads(__tstate);
45087 if (PyErr_Occurred()) SWIG_fail;
45088 }
45089 {
45090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45091 }
45092 return resultobj;
45093 fail:
45094 return NULL;
45095 }
45096
45097
45098 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45099 PyObject *resultobj = 0;
45100 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45101 bool result;
45102 void *argp1 = 0 ;
45103 int res1 = 0 ;
45104 PyObject *swig_obj[1] ;
45105
45106 if (!args) SWIG_fail;
45107 swig_obj[0] = args;
45108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45109 if (!SWIG_IsOK(res1)) {
45110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45111 }
45112 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45113 {
45114 PyThreadState* __tstate = wxPyBeginAllowThreads();
45115 result = (bool)(arg1)->IsSizer();
45116 wxPyEndAllowThreads(__tstate);
45117 if (PyErr_Occurred()) SWIG_fail;
45118 }
45119 {
45120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45121 }
45122 return resultobj;
45123 fail:
45124 return NULL;
45125 }
45126
45127
45128 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45129 PyObject *resultobj = 0;
45130 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45131 bool result;
45132 void *argp1 = 0 ;
45133 int res1 = 0 ;
45134 PyObject *swig_obj[1] ;
45135
45136 if (!args) SWIG_fail;
45137 swig_obj[0] = args;
45138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45139 if (!SWIG_IsOK(res1)) {
45140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45141 }
45142 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45143 {
45144 PyThreadState* __tstate = wxPyBeginAllowThreads();
45145 result = (bool)(arg1)->IsSpacer();
45146 wxPyEndAllowThreads(__tstate);
45147 if (PyErr_Occurred()) SWIG_fail;
45148 }
45149 {
45150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45151 }
45152 return resultobj;
45153 fail:
45154 return NULL;
45155 }
45156
45157
45158 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45159 PyObject *resultobj = 0;
45160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45161 int arg2 ;
45162 void *argp1 = 0 ;
45163 int res1 = 0 ;
45164 int val2 ;
45165 int ecode2 = 0 ;
45166 PyObject * obj0 = 0 ;
45167 PyObject * obj1 = 0 ;
45168 char * kwnames[] = {
45169 (char *) "self",(char *) "proportion", NULL
45170 };
45171
45172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45176 }
45177 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45178 ecode2 = SWIG_AsVal_int(obj1, &val2);
45179 if (!SWIG_IsOK(ecode2)) {
45180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45181 }
45182 arg2 = static_cast< int >(val2);
45183 {
45184 PyThreadState* __tstate = wxPyBeginAllowThreads();
45185 (arg1)->SetProportion(arg2);
45186 wxPyEndAllowThreads(__tstate);
45187 if (PyErr_Occurred()) SWIG_fail;
45188 }
45189 resultobj = SWIG_Py_Void();
45190 return resultobj;
45191 fail:
45192 return NULL;
45193 }
45194
45195
45196 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45197 PyObject *resultobj = 0;
45198 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45199 int result;
45200 void *argp1 = 0 ;
45201 int res1 = 0 ;
45202 PyObject *swig_obj[1] ;
45203
45204 if (!args) SWIG_fail;
45205 swig_obj[0] = args;
45206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45207 if (!SWIG_IsOK(res1)) {
45208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45209 }
45210 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45211 {
45212 PyThreadState* __tstate = wxPyBeginAllowThreads();
45213 result = (int)(arg1)->GetProportion();
45214 wxPyEndAllowThreads(__tstate);
45215 if (PyErr_Occurred()) SWIG_fail;
45216 }
45217 resultobj = SWIG_From_int(static_cast< int >(result));
45218 return resultobj;
45219 fail:
45220 return NULL;
45221 }
45222
45223
45224 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45225 PyObject *resultobj = 0;
45226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45227 int arg2 ;
45228 void *argp1 = 0 ;
45229 int res1 = 0 ;
45230 int val2 ;
45231 int ecode2 = 0 ;
45232 PyObject * obj0 = 0 ;
45233 PyObject * obj1 = 0 ;
45234 char * kwnames[] = {
45235 (char *) "self",(char *) "flag", NULL
45236 };
45237
45238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45240 if (!SWIG_IsOK(res1)) {
45241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45242 }
45243 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45244 ecode2 = SWIG_AsVal_int(obj1, &val2);
45245 if (!SWIG_IsOK(ecode2)) {
45246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45247 }
45248 arg2 = static_cast< int >(val2);
45249 {
45250 PyThreadState* __tstate = wxPyBeginAllowThreads();
45251 (arg1)->SetFlag(arg2);
45252 wxPyEndAllowThreads(__tstate);
45253 if (PyErr_Occurred()) SWIG_fail;
45254 }
45255 resultobj = SWIG_Py_Void();
45256 return resultobj;
45257 fail:
45258 return NULL;
45259 }
45260
45261
45262 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45263 PyObject *resultobj = 0;
45264 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45265 int result;
45266 void *argp1 = 0 ;
45267 int res1 = 0 ;
45268 PyObject *swig_obj[1] ;
45269
45270 if (!args) SWIG_fail;
45271 swig_obj[0] = args;
45272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45273 if (!SWIG_IsOK(res1)) {
45274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45275 }
45276 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45277 {
45278 PyThreadState* __tstate = wxPyBeginAllowThreads();
45279 result = (int)(arg1)->GetFlag();
45280 wxPyEndAllowThreads(__tstate);
45281 if (PyErr_Occurred()) SWIG_fail;
45282 }
45283 resultobj = SWIG_From_int(static_cast< int >(result));
45284 return resultobj;
45285 fail:
45286 return NULL;
45287 }
45288
45289
45290 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45291 PyObject *resultobj = 0;
45292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45293 int arg2 ;
45294 void *argp1 = 0 ;
45295 int res1 = 0 ;
45296 int val2 ;
45297 int ecode2 = 0 ;
45298 PyObject * obj0 = 0 ;
45299 PyObject * obj1 = 0 ;
45300 char * kwnames[] = {
45301 (char *) "self",(char *) "border", NULL
45302 };
45303
45304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45306 if (!SWIG_IsOK(res1)) {
45307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45308 }
45309 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45310 ecode2 = SWIG_AsVal_int(obj1, &val2);
45311 if (!SWIG_IsOK(ecode2)) {
45312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45313 }
45314 arg2 = static_cast< int >(val2);
45315 {
45316 PyThreadState* __tstate = wxPyBeginAllowThreads();
45317 (arg1)->SetBorder(arg2);
45318 wxPyEndAllowThreads(__tstate);
45319 if (PyErr_Occurred()) SWIG_fail;
45320 }
45321 resultobj = SWIG_Py_Void();
45322 return resultobj;
45323 fail:
45324 return NULL;
45325 }
45326
45327
45328 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45329 PyObject *resultobj = 0;
45330 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45331 int result;
45332 void *argp1 = 0 ;
45333 int res1 = 0 ;
45334 PyObject *swig_obj[1] ;
45335
45336 if (!args) SWIG_fail;
45337 swig_obj[0] = args;
45338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45339 if (!SWIG_IsOK(res1)) {
45340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45341 }
45342 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45343 {
45344 PyThreadState* __tstate = wxPyBeginAllowThreads();
45345 result = (int)(arg1)->GetBorder();
45346 wxPyEndAllowThreads(__tstate);
45347 if (PyErr_Occurred()) SWIG_fail;
45348 }
45349 resultobj = SWIG_From_int(static_cast< int >(result));
45350 return resultobj;
45351 fail:
45352 return NULL;
45353 }
45354
45355
45356 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45357 PyObject *resultobj = 0;
45358 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45359 wxWindow *result = 0 ;
45360 void *argp1 = 0 ;
45361 int res1 = 0 ;
45362 PyObject *swig_obj[1] ;
45363
45364 if (!args) SWIG_fail;
45365 swig_obj[0] = args;
45366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45367 if (!SWIG_IsOK(res1)) {
45368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45369 }
45370 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45371 {
45372 PyThreadState* __tstate = wxPyBeginAllowThreads();
45373 result = (wxWindow *)(arg1)->GetWindow();
45374 wxPyEndAllowThreads(__tstate);
45375 if (PyErr_Occurred()) SWIG_fail;
45376 }
45377 {
45378 resultobj = wxPyMake_wxObject(result, 0);
45379 }
45380 return resultobj;
45381 fail:
45382 return NULL;
45383 }
45384
45385
45386 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45387 PyObject *resultobj = 0;
45388 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45389 wxWindow *arg2 = (wxWindow *) 0 ;
45390 void *argp1 = 0 ;
45391 int res1 = 0 ;
45392 void *argp2 = 0 ;
45393 int res2 = 0 ;
45394 PyObject * obj0 = 0 ;
45395 PyObject * obj1 = 0 ;
45396 char * kwnames[] = {
45397 (char *) "self",(char *) "window", NULL
45398 };
45399
45400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45402 if (!SWIG_IsOK(res1)) {
45403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45404 }
45405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45407 if (!SWIG_IsOK(res2)) {
45408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45409 }
45410 arg2 = reinterpret_cast< wxWindow * >(argp2);
45411 {
45412 PyThreadState* __tstate = wxPyBeginAllowThreads();
45413 (arg1)->SetWindow(arg2);
45414 wxPyEndAllowThreads(__tstate);
45415 if (PyErr_Occurred()) SWIG_fail;
45416 }
45417 resultobj = SWIG_Py_Void();
45418 return resultobj;
45419 fail:
45420 return NULL;
45421 }
45422
45423
45424 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45425 PyObject *resultobj = 0;
45426 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45427 wxSizer *result = 0 ;
45428 void *argp1 = 0 ;
45429 int res1 = 0 ;
45430 PyObject *swig_obj[1] ;
45431
45432 if (!args) SWIG_fail;
45433 swig_obj[0] = args;
45434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45435 if (!SWIG_IsOK(res1)) {
45436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45437 }
45438 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45439 {
45440 PyThreadState* __tstate = wxPyBeginAllowThreads();
45441 result = (wxSizer *)(arg1)->GetSizer();
45442 wxPyEndAllowThreads(__tstate);
45443 if (PyErr_Occurred()) SWIG_fail;
45444 }
45445 {
45446 resultobj = wxPyMake_wxObject(result, (bool)0);
45447 }
45448 return resultobj;
45449 fail:
45450 return NULL;
45451 }
45452
45453
45454 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45455 PyObject *resultobj = 0;
45456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45457 wxSizer *arg2 = (wxSizer *) 0 ;
45458 void *argp1 = 0 ;
45459 int res1 = 0 ;
45460 int res2 = 0 ;
45461 PyObject * obj0 = 0 ;
45462 PyObject * obj1 = 0 ;
45463 char * kwnames[] = {
45464 (char *) "self",(char *) "sizer", NULL
45465 };
45466
45467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45469 if (!SWIG_IsOK(res1)) {
45470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45471 }
45472 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45473 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45474 if (!SWIG_IsOK(res2)) {
45475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45476 }
45477 {
45478 PyThreadState* __tstate = wxPyBeginAllowThreads();
45479 (arg1)->SetSizer(arg2);
45480 wxPyEndAllowThreads(__tstate);
45481 if (PyErr_Occurred()) SWIG_fail;
45482 }
45483 resultobj = SWIG_Py_Void();
45484 return resultobj;
45485 fail:
45486 return NULL;
45487 }
45488
45489
45490 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45491 PyObject *resultobj = 0;
45492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45493 wxSize *result = 0 ;
45494 void *argp1 = 0 ;
45495 int res1 = 0 ;
45496 PyObject *swig_obj[1] ;
45497
45498 if (!args) SWIG_fail;
45499 swig_obj[0] = args;
45500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45501 if (!SWIG_IsOK(res1)) {
45502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45503 }
45504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45505 {
45506 PyThreadState* __tstate = wxPyBeginAllowThreads();
45507 {
45508 wxSize const &_result_ref = (arg1)->GetSpacer();
45509 result = (wxSize *) &_result_ref;
45510 }
45511 wxPyEndAllowThreads(__tstate);
45512 if (PyErr_Occurred()) SWIG_fail;
45513 }
45514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45515 return resultobj;
45516 fail:
45517 return NULL;
45518 }
45519
45520
45521 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj = 0;
45523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45524 wxSize *arg2 = 0 ;
45525 void *argp1 = 0 ;
45526 int res1 = 0 ;
45527 wxSize temp2 ;
45528 PyObject * obj0 = 0 ;
45529 PyObject * obj1 = 0 ;
45530 char * kwnames[] = {
45531 (char *) "self",(char *) "size", NULL
45532 };
45533
45534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45536 if (!SWIG_IsOK(res1)) {
45537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45538 }
45539 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45540 {
45541 arg2 = &temp2;
45542 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45543 }
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 (arg1)->SetSpacer((wxSize const &)*arg2);
45547 wxPyEndAllowThreads(__tstate);
45548 if (PyErr_Occurred()) SWIG_fail;
45549 }
45550 resultobj = SWIG_Py_Void();
45551 return resultobj;
45552 fail:
45553 return NULL;
45554 }
45555
45556
45557 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45558 PyObject *resultobj = 0;
45559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45560 bool arg2 ;
45561 void *argp1 = 0 ;
45562 int res1 = 0 ;
45563 bool val2 ;
45564 int ecode2 = 0 ;
45565 PyObject * obj0 = 0 ;
45566 PyObject * obj1 = 0 ;
45567 char * kwnames[] = {
45568 (char *) "self",(char *) "show", NULL
45569 };
45570
45571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45573 if (!SWIG_IsOK(res1)) {
45574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45575 }
45576 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45578 if (!SWIG_IsOK(ecode2)) {
45579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45580 }
45581 arg2 = static_cast< bool >(val2);
45582 {
45583 PyThreadState* __tstate = wxPyBeginAllowThreads();
45584 (arg1)->Show(arg2);
45585 wxPyEndAllowThreads(__tstate);
45586 if (PyErr_Occurred()) SWIG_fail;
45587 }
45588 resultobj = SWIG_Py_Void();
45589 return resultobj;
45590 fail:
45591 return NULL;
45592 }
45593
45594
45595 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45596 PyObject *resultobj = 0;
45597 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45598 bool result;
45599 void *argp1 = 0 ;
45600 int res1 = 0 ;
45601 PyObject *swig_obj[1] ;
45602
45603 if (!args) SWIG_fail;
45604 swig_obj[0] = args;
45605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45606 if (!SWIG_IsOK(res1)) {
45607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45608 }
45609 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45610 {
45611 PyThreadState* __tstate = wxPyBeginAllowThreads();
45612 result = (bool)(arg1)->IsShown();
45613 wxPyEndAllowThreads(__tstate);
45614 if (PyErr_Occurred()) SWIG_fail;
45615 }
45616 {
45617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45618 }
45619 return resultobj;
45620 fail:
45621 return NULL;
45622 }
45623
45624
45625 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45626 PyObject *resultobj = 0;
45627 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45628 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45638 }
45639 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45640 {
45641 PyThreadState* __tstate = wxPyBeginAllowThreads();
45642 result = (arg1)->GetPosition();
45643 wxPyEndAllowThreads(__tstate);
45644 if (PyErr_Occurred()) SWIG_fail;
45645 }
45646 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45647 return resultobj;
45648 fail:
45649 return NULL;
45650 }
45651
45652
45653 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45654 PyObject *resultobj = 0;
45655 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45656 PyObject *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_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45666 }
45667 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45668 {
45669 PyThreadState* __tstate = wxPyBeginAllowThreads();
45670 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45671 wxPyEndAllowThreads(__tstate);
45672 if (PyErr_Occurred()) SWIG_fail;
45673 }
45674 resultobj = result;
45675 return resultobj;
45676 fail:
45677 return NULL;
45678 }
45679
45680
45681 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45682 PyObject *resultobj = 0;
45683 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45684 PyObject *arg2 = (PyObject *) 0 ;
45685 void *argp1 = 0 ;
45686 int res1 = 0 ;
45687 PyObject * obj0 = 0 ;
45688 PyObject * obj1 = 0 ;
45689 char * kwnames[] = {
45690 (char *) "self",(char *) "userData", NULL
45691 };
45692
45693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45695 if (!SWIG_IsOK(res1)) {
45696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45697 }
45698 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45699 arg2 = obj1;
45700 {
45701 PyThreadState* __tstate = wxPyBeginAllowThreads();
45702 wxSizerItem_SetUserData(arg1,arg2);
45703 wxPyEndAllowThreads(__tstate);
45704 if (PyErr_Occurred()) SWIG_fail;
45705 }
45706 resultobj = SWIG_Py_Void();
45707 return resultobj;
45708 fail:
45709 return NULL;
45710 }
45711
45712
45713 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45714 PyObject *obj;
45715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45716 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45717 return SWIG_Py_Void();
45718 }
45719
45720 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45721 return SWIG_Python_InitShadowInstance(args);
45722 }
45723
45724 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45725 PyObject *resultobj = 0;
45726 wxSizer *arg1 = (wxSizer *) 0 ;
45727 void *argp1 = 0 ;
45728 int res1 = 0 ;
45729 PyObject *swig_obj[1] ;
45730
45731 if (!args) SWIG_fail;
45732 swig_obj[0] = args;
45733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45734 if (!SWIG_IsOK(res1)) {
45735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45736 }
45737 arg1 = reinterpret_cast< wxSizer * >(argp1);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 delete arg1;
45741
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 resultobj = SWIG_Py_Void();
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxSizer *arg1 = (wxSizer *) 0 ;
45755 PyObject *arg2 = (PyObject *) 0 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 PyObject * obj0 = 0 ;
45759 PyObject * obj1 = 0 ;
45760 char * kwnames[] = {
45761 (char *) "self",(char *) "_self", NULL
45762 };
45763
45764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45766 if (!SWIG_IsOK(res1)) {
45767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45768 }
45769 arg1 = reinterpret_cast< wxSizer * >(argp1);
45770 arg2 = obj1;
45771 {
45772 PyThreadState* __tstate = wxPyBeginAllowThreads();
45773 wxSizer__setOORInfo(arg1,arg2);
45774 wxPyEndAllowThreads(__tstate);
45775 if (PyErr_Occurred()) SWIG_fail;
45776 }
45777 resultobj = SWIG_Py_Void();
45778 return resultobj;
45779 fail:
45780 return NULL;
45781 }
45782
45783
45784 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45785 PyObject *resultobj = 0;
45786 wxSizer *arg1 = (wxSizer *) 0 ;
45787 PyObject *arg2 = (PyObject *) 0 ;
45788 int arg3 = (int) 0 ;
45789 int arg4 = (int) 0 ;
45790 int arg5 = (int) 0 ;
45791 PyObject *arg6 = (PyObject *) NULL ;
45792 wxSizerItem *result = 0 ;
45793 void *argp1 = 0 ;
45794 int res1 = 0 ;
45795 int val3 ;
45796 int ecode3 = 0 ;
45797 int val4 ;
45798 int ecode4 = 0 ;
45799 int val5 ;
45800 int ecode5 = 0 ;
45801 PyObject * obj0 = 0 ;
45802 PyObject * obj1 = 0 ;
45803 PyObject * obj2 = 0 ;
45804 PyObject * obj3 = 0 ;
45805 PyObject * obj4 = 0 ;
45806 PyObject * obj5 = 0 ;
45807 char * kwnames[] = {
45808 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45809 };
45810
45811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45813 if (!SWIG_IsOK(res1)) {
45814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45815 }
45816 arg1 = reinterpret_cast< wxSizer * >(argp1);
45817 arg2 = obj1;
45818 if (obj2) {
45819 ecode3 = SWIG_AsVal_int(obj2, &val3);
45820 if (!SWIG_IsOK(ecode3)) {
45821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45822 }
45823 arg3 = static_cast< int >(val3);
45824 }
45825 if (obj3) {
45826 ecode4 = SWIG_AsVal_int(obj3, &val4);
45827 if (!SWIG_IsOK(ecode4)) {
45828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45829 }
45830 arg4 = static_cast< int >(val4);
45831 }
45832 if (obj4) {
45833 ecode5 = SWIG_AsVal_int(obj4, &val5);
45834 if (!SWIG_IsOK(ecode5)) {
45835 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45836 }
45837 arg5 = static_cast< int >(val5);
45838 }
45839 if (obj5) {
45840 arg6 = obj5;
45841 }
45842 {
45843 PyThreadState* __tstate = wxPyBeginAllowThreads();
45844 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45845 wxPyEndAllowThreads(__tstate);
45846 if (PyErr_Occurred()) SWIG_fail;
45847 }
45848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj = 0;
45857 wxSizer *arg1 = (wxSizer *) 0 ;
45858 int arg2 ;
45859 PyObject *arg3 = (PyObject *) 0 ;
45860 int arg4 = (int) 0 ;
45861 int arg5 = (int) 0 ;
45862 int arg6 = (int) 0 ;
45863 PyObject *arg7 = (PyObject *) NULL ;
45864 wxSizerItem *result = 0 ;
45865 void *argp1 = 0 ;
45866 int res1 = 0 ;
45867 int val2 ;
45868 int ecode2 = 0 ;
45869 int val4 ;
45870 int ecode4 = 0 ;
45871 int val5 ;
45872 int ecode5 = 0 ;
45873 int val6 ;
45874 int ecode6 = 0 ;
45875 PyObject * obj0 = 0 ;
45876 PyObject * obj1 = 0 ;
45877 PyObject * obj2 = 0 ;
45878 PyObject * obj3 = 0 ;
45879 PyObject * obj4 = 0 ;
45880 PyObject * obj5 = 0 ;
45881 PyObject * obj6 = 0 ;
45882 char * kwnames[] = {
45883 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45884 };
45885
45886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45888 if (!SWIG_IsOK(res1)) {
45889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
45890 }
45891 arg1 = reinterpret_cast< wxSizer * >(argp1);
45892 ecode2 = SWIG_AsVal_int(obj1, &val2);
45893 if (!SWIG_IsOK(ecode2)) {
45894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
45895 }
45896 arg2 = static_cast< int >(val2);
45897 arg3 = obj2;
45898 if (obj3) {
45899 ecode4 = SWIG_AsVal_int(obj3, &val4);
45900 if (!SWIG_IsOK(ecode4)) {
45901 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
45902 }
45903 arg4 = static_cast< int >(val4);
45904 }
45905 if (obj4) {
45906 ecode5 = SWIG_AsVal_int(obj4, &val5);
45907 if (!SWIG_IsOK(ecode5)) {
45908 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
45909 }
45910 arg5 = static_cast< int >(val5);
45911 }
45912 if (obj5) {
45913 ecode6 = SWIG_AsVal_int(obj5, &val6);
45914 if (!SWIG_IsOK(ecode6)) {
45915 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
45916 }
45917 arg6 = static_cast< int >(val6);
45918 }
45919 if (obj6) {
45920 arg7 = obj6;
45921 }
45922 {
45923 PyThreadState* __tstate = wxPyBeginAllowThreads();
45924 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
45925 wxPyEndAllowThreads(__tstate);
45926 if (PyErr_Occurred()) SWIG_fail;
45927 }
45928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45929 return resultobj;
45930 fail:
45931 return NULL;
45932 }
45933
45934
45935 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45936 PyObject *resultobj = 0;
45937 wxSizer *arg1 = (wxSizer *) 0 ;
45938 PyObject *arg2 = (PyObject *) 0 ;
45939 int arg3 = (int) 0 ;
45940 int arg4 = (int) 0 ;
45941 int arg5 = (int) 0 ;
45942 PyObject *arg6 = (PyObject *) NULL ;
45943 wxSizerItem *result = 0 ;
45944 void *argp1 = 0 ;
45945 int res1 = 0 ;
45946 int val3 ;
45947 int ecode3 = 0 ;
45948 int val4 ;
45949 int ecode4 = 0 ;
45950 int val5 ;
45951 int ecode5 = 0 ;
45952 PyObject * obj0 = 0 ;
45953 PyObject * obj1 = 0 ;
45954 PyObject * obj2 = 0 ;
45955 PyObject * obj3 = 0 ;
45956 PyObject * obj4 = 0 ;
45957 PyObject * obj5 = 0 ;
45958 char * kwnames[] = {
45959 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45960 };
45961
45962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45964 if (!SWIG_IsOK(res1)) {
45965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
45966 }
45967 arg1 = reinterpret_cast< wxSizer * >(argp1);
45968 arg2 = obj1;
45969 if (obj2) {
45970 ecode3 = SWIG_AsVal_int(obj2, &val3);
45971 if (!SWIG_IsOK(ecode3)) {
45972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
45973 }
45974 arg3 = static_cast< int >(val3);
45975 }
45976 if (obj3) {
45977 ecode4 = SWIG_AsVal_int(obj3, &val4);
45978 if (!SWIG_IsOK(ecode4)) {
45979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
45980 }
45981 arg4 = static_cast< int >(val4);
45982 }
45983 if (obj4) {
45984 ecode5 = SWIG_AsVal_int(obj4, &val5);
45985 if (!SWIG_IsOK(ecode5)) {
45986 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
45987 }
45988 arg5 = static_cast< int >(val5);
45989 }
45990 if (obj5) {
45991 arg6 = obj5;
45992 }
45993 {
45994 PyThreadState* __tstate = wxPyBeginAllowThreads();
45995 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
45996 wxPyEndAllowThreads(__tstate);
45997 if (PyErr_Occurred()) SWIG_fail;
45998 }
45999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46000 return resultobj;
46001 fail:
46002 return NULL;
46003 }
46004
46005
46006 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46007 PyObject *resultobj = 0;
46008 wxSizer *arg1 = (wxSizer *) 0 ;
46009 PyObject *arg2 = (PyObject *) 0 ;
46010 bool result;
46011 void *argp1 = 0 ;
46012 int res1 = 0 ;
46013 PyObject * obj0 = 0 ;
46014 PyObject * obj1 = 0 ;
46015 char * kwnames[] = {
46016 (char *) "self",(char *) "item", NULL
46017 };
46018
46019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46021 if (!SWIG_IsOK(res1)) {
46022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46023 }
46024 arg1 = reinterpret_cast< wxSizer * >(argp1);
46025 arg2 = obj1;
46026 {
46027 PyThreadState* __tstate = wxPyBeginAllowThreads();
46028 result = (bool)wxSizer_Remove(arg1,arg2);
46029 wxPyEndAllowThreads(__tstate);
46030 if (PyErr_Occurred()) SWIG_fail;
46031 }
46032 {
46033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46034 }
46035 return resultobj;
46036 fail:
46037 return NULL;
46038 }
46039
46040
46041 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46042 PyObject *resultobj = 0;
46043 wxSizer *arg1 = (wxSizer *) 0 ;
46044 PyObject *arg2 = (PyObject *) 0 ;
46045 bool result;
46046 void *argp1 = 0 ;
46047 int res1 = 0 ;
46048 PyObject * obj0 = 0 ;
46049 PyObject * obj1 = 0 ;
46050 char * kwnames[] = {
46051 (char *) "self",(char *) "item", NULL
46052 };
46053
46054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46056 if (!SWIG_IsOK(res1)) {
46057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46058 }
46059 arg1 = reinterpret_cast< wxSizer * >(argp1);
46060 arg2 = obj1;
46061 {
46062 PyThreadState* __tstate = wxPyBeginAllowThreads();
46063 result = (bool)wxSizer_Detach(arg1,arg2);
46064 wxPyEndAllowThreads(__tstate);
46065 if (PyErr_Occurred()) SWIG_fail;
46066 }
46067 {
46068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46069 }
46070 return resultobj;
46071 fail:
46072 return NULL;
46073 }
46074
46075
46076 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46077 PyObject *resultobj = 0;
46078 wxSizer *arg1 = (wxSizer *) 0 ;
46079 PyObject *arg2 = (PyObject *) 0 ;
46080 wxSizerItem *result = 0 ;
46081 void *argp1 = 0 ;
46082 int res1 = 0 ;
46083 PyObject * obj0 = 0 ;
46084 PyObject * obj1 = 0 ;
46085 char * kwnames[] = {
46086 (char *) "self",(char *) "item", NULL
46087 };
46088
46089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46091 if (!SWIG_IsOK(res1)) {
46092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46093 }
46094 arg1 = reinterpret_cast< wxSizer * >(argp1);
46095 arg2 = obj1;
46096 {
46097 PyThreadState* __tstate = wxPyBeginAllowThreads();
46098 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46099 wxPyEndAllowThreads(__tstate);
46100 if (PyErr_Occurred()) SWIG_fail;
46101 }
46102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46103 return resultobj;
46104 fail:
46105 return NULL;
46106 }
46107
46108
46109 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46110 PyObject *resultobj = 0;
46111 wxSizer *arg1 = (wxSizer *) 0 ;
46112 PyObject *arg2 = (PyObject *) 0 ;
46113 wxSize *arg3 = 0 ;
46114 void *argp1 = 0 ;
46115 int res1 = 0 ;
46116 wxSize temp3 ;
46117 PyObject * obj0 = 0 ;
46118 PyObject * obj1 = 0 ;
46119 PyObject * obj2 = 0 ;
46120 char * kwnames[] = {
46121 (char *) "self",(char *) "item",(char *) "size", NULL
46122 };
46123
46124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46126 if (!SWIG_IsOK(res1)) {
46127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46128 }
46129 arg1 = reinterpret_cast< wxSizer * >(argp1);
46130 arg2 = obj1;
46131 {
46132 arg3 = &temp3;
46133 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46134 }
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46138 wxPyEndAllowThreads(__tstate);
46139 if (PyErr_Occurred()) SWIG_fail;
46140 }
46141 resultobj = SWIG_Py_Void();
46142 return resultobj;
46143 fail:
46144 return NULL;
46145 }
46146
46147
46148 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46149 PyObject *resultobj = 0;
46150 wxSizer *arg1 = (wxSizer *) 0 ;
46151 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46152 wxSizerItem *result = 0 ;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 int res2 = 0 ;
46156 PyObject * obj0 = 0 ;
46157 PyObject * obj1 = 0 ;
46158 char * kwnames[] = {
46159 (char *) "self",(char *) "item", NULL
46160 };
46161
46162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46164 if (!SWIG_IsOK(res1)) {
46165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46166 }
46167 arg1 = reinterpret_cast< wxSizer * >(argp1);
46168 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46169 if (!SWIG_IsOK(res2)) {
46170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46171 }
46172 {
46173 PyThreadState* __tstate = wxPyBeginAllowThreads();
46174 result = (wxSizerItem *)(arg1)->Add(arg2);
46175 wxPyEndAllowThreads(__tstate);
46176 if (PyErr_Occurred()) SWIG_fail;
46177 }
46178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46179 return resultobj;
46180 fail:
46181 return NULL;
46182 }
46183
46184
46185 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46186 PyObject *resultobj = 0;
46187 wxSizer *arg1 = (wxSizer *) 0 ;
46188 size_t arg2 ;
46189 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46190 wxSizerItem *result = 0 ;
46191 void *argp1 = 0 ;
46192 int res1 = 0 ;
46193 size_t val2 ;
46194 int ecode2 = 0 ;
46195 int res3 = 0 ;
46196 PyObject * obj0 = 0 ;
46197 PyObject * obj1 = 0 ;
46198 PyObject * obj2 = 0 ;
46199 char * kwnames[] = {
46200 (char *) "self",(char *) "index",(char *) "item", NULL
46201 };
46202
46203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46205 if (!SWIG_IsOK(res1)) {
46206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46207 }
46208 arg1 = reinterpret_cast< wxSizer * >(argp1);
46209 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46210 if (!SWIG_IsOK(ecode2)) {
46211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46212 }
46213 arg2 = static_cast< size_t >(val2);
46214 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46215 if (!SWIG_IsOK(res3)) {
46216 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46217 }
46218 {
46219 PyThreadState* __tstate = wxPyBeginAllowThreads();
46220 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46221 wxPyEndAllowThreads(__tstate);
46222 if (PyErr_Occurred()) SWIG_fail;
46223 }
46224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46225 return resultobj;
46226 fail:
46227 return NULL;
46228 }
46229
46230
46231 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46232 PyObject *resultobj = 0;
46233 wxSizer *arg1 = (wxSizer *) 0 ;
46234 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46235 wxSizerItem *result = 0 ;
46236 void *argp1 = 0 ;
46237 int res1 = 0 ;
46238 int res2 = 0 ;
46239 PyObject * obj0 = 0 ;
46240 PyObject * obj1 = 0 ;
46241 char * kwnames[] = {
46242 (char *) "self",(char *) "item", NULL
46243 };
46244
46245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46247 if (!SWIG_IsOK(res1)) {
46248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46249 }
46250 arg1 = reinterpret_cast< wxSizer * >(argp1);
46251 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46252 if (!SWIG_IsOK(res2)) {
46253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46254 }
46255 {
46256 PyThreadState* __tstate = wxPyBeginAllowThreads();
46257 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46258 wxPyEndAllowThreads(__tstate);
46259 if (PyErr_Occurred()) SWIG_fail;
46260 }
46261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46262 return resultobj;
46263 fail:
46264 return NULL;
46265 }
46266
46267
46268 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46269 PyObject *resultobj = 0;
46270 wxSizer *arg1 = (wxSizer *) 0 ;
46271 int arg2 ;
46272 int arg3 ;
46273 int arg4 ;
46274 int arg5 ;
46275 void *argp1 = 0 ;
46276 int res1 = 0 ;
46277 int val2 ;
46278 int ecode2 = 0 ;
46279 int val3 ;
46280 int ecode3 = 0 ;
46281 int val4 ;
46282 int ecode4 = 0 ;
46283 int val5 ;
46284 int ecode5 = 0 ;
46285 PyObject * obj0 = 0 ;
46286 PyObject * obj1 = 0 ;
46287 PyObject * obj2 = 0 ;
46288 PyObject * obj3 = 0 ;
46289 PyObject * obj4 = 0 ;
46290 char * kwnames[] = {
46291 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46292 };
46293
46294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46296 if (!SWIG_IsOK(res1)) {
46297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46298 }
46299 arg1 = reinterpret_cast< wxSizer * >(argp1);
46300 ecode2 = SWIG_AsVal_int(obj1, &val2);
46301 if (!SWIG_IsOK(ecode2)) {
46302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46303 }
46304 arg2 = static_cast< int >(val2);
46305 ecode3 = SWIG_AsVal_int(obj2, &val3);
46306 if (!SWIG_IsOK(ecode3)) {
46307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46308 }
46309 arg3 = static_cast< int >(val3);
46310 ecode4 = SWIG_AsVal_int(obj3, &val4);
46311 if (!SWIG_IsOK(ecode4)) {
46312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46313 }
46314 arg4 = static_cast< int >(val4);
46315 ecode5 = SWIG_AsVal_int(obj4, &val5);
46316 if (!SWIG_IsOK(ecode5)) {
46317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46318 }
46319 arg5 = static_cast< int >(val5);
46320 {
46321 PyThreadState* __tstate = wxPyBeginAllowThreads();
46322 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46323 wxPyEndAllowThreads(__tstate);
46324 if (PyErr_Occurred()) SWIG_fail;
46325 }
46326 resultobj = SWIG_Py_Void();
46327 return resultobj;
46328 fail:
46329 return NULL;
46330 }
46331
46332
46333 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46334 PyObject *resultobj = 0;
46335 wxSizer *arg1 = (wxSizer *) 0 ;
46336 wxSize *arg2 = 0 ;
46337 void *argp1 = 0 ;
46338 int res1 = 0 ;
46339 wxSize temp2 ;
46340 PyObject * obj0 = 0 ;
46341 PyObject * obj1 = 0 ;
46342 char * kwnames[] = {
46343 (char *) "self",(char *) "size", NULL
46344 };
46345
46346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46348 if (!SWIG_IsOK(res1)) {
46349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46350 }
46351 arg1 = reinterpret_cast< wxSizer * >(argp1);
46352 {
46353 arg2 = &temp2;
46354 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46355 }
46356 {
46357 PyThreadState* __tstate = wxPyBeginAllowThreads();
46358 (arg1)->SetMinSize((wxSize const &)*arg2);
46359 wxPyEndAllowThreads(__tstate);
46360 if (PyErr_Occurred()) SWIG_fail;
46361 }
46362 resultobj = SWIG_Py_Void();
46363 return resultobj;
46364 fail:
46365 return NULL;
46366 }
46367
46368
46369 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46370 PyObject *resultobj = 0;
46371 wxSizer *arg1 = (wxSizer *) 0 ;
46372 wxSize result;
46373 void *argp1 = 0 ;
46374 int res1 = 0 ;
46375 PyObject *swig_obj[1] ;
46376
46377 if (!args) SWIG_fail;
46378 swig_obj[0] = args;
46379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46380 if (!SWIG_IsOK(res1)) {
46381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46382 }
46383 arg1 = reinterpret_cast< wxSizer * >(argp1);
46384 {
46385 PyThreadState* __tstate = wxPyBeginAllowThreads();
46386 result = (arg1)->GetSize();
46387 wxPyEndAllowThreads(__tstate);
46388 if (PyErr_Occurred()) SWIG_fail;
46389 }
46390 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46391 return resultobj;
46392 fail:
46393 return NULL;
46394 }
46395
46396
46397 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46398 PyObject *resultobj = 0;
46399 wxSizer *arg1 = (wxSizer *) 0 ;
46400 wxPoint result;
46401 void *argp1 = 0 ;
46402 int res1 = 0 ;
46403 PyObject *swig_obj[1] ;
46404
46405 if (!args) SWIG_fail;
46406 swig_obj[0] = args;
46407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46408 if (!SWIG_IsOK(res1)) {
46409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46410 }
46411 arg1 = reinterpret_cast< wxSizer * >(argp1);
46412 {
46413 PyThreadState* __tstate = wxPyBeginAllowThreads();
46414 result = (arg1)->GetPosition();
46415 wxPyEndAllowThreads(__tstate);
46416 if (PyErr_Occurred()) SWIG_fail;
46417 }
46418 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46419 return resultobj;
46420 fail:
46421 return NULL;
46422 }
46423
46424
46425 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46426 PyObject *resultobj = 0;
46427 wxSizer *arg1 = (wxSizer *) 0 ;
46428 wxSize result;
46429 void *argp1 = 0 ;
46430 int res1 = 0 ;
46431 PyObject *swig_obj[1] ;
46432
46433 if (!args) SWIG_fail;
46434 swig_obj[0] = args;
46435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46436 if (!SWIG_IsOK(res1)) {
46437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46438 }
46439 arg1 = reinterpret_cast< wxSizer * >(argp1);
46440 {
46441 PyThreadState* __tstate = wxPyBeginAllowThreads();
46442 result = (arg1)->GetMinSize();
46443 wxPyEndAllowThreads(__tstate);
46444 if (PyErr_Occurred()) SWIG_fail;
46445 }
46446 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46447 return resultobj;
46448 fail:
46449 return NULL;
46450 }
46451
46452
46453 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46454 PyObject *resultobj = 0;
46455 wxSizer *arg1 = (wxSizer *) 0 ;
46456 void *argp1 = 0 ;
46457 int res1 = 0 ;
46458 PyObject *swig_obj[1] ;
46459
46460 if (!args) SWIG_fail;
46461 swig_obj[0] = args;
46462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46463 if (!SWIG_IsOK(res1)) {
46464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46465 }
46466 arg1 = reinterpret_cast< wxSizer * >(argp1);
46467 {
46468 PyThreadState* __tstate = wxPyBeginAllowThreads();
46469 (arg1)->RecalcSizes();
46470 wxPyEndAllowThreads(__tstate);
46471 if (PyErr_Occurred()) SWIG_fail;
46472 }
46473 resultobj = SWIG_Py_Void();
46474 return resultobj;
46475 fail:
46476 return NULL;
46477 }
46478
46479
46480 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46481 PyObject *resultobj = 0;
46482 wxSizer *arg1 = (wxSizer *) 0 ;
46483 wxSize result;
46484 void *argp1 = 0 ;
46485 int res1 = 0 ;
46486 PyObject *swig_obj[1] ;
46487
46488 if (!args) SWIG_fail;
46489 swig_obj[0] = args;
46490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46491 if (!SWIG_IsOK(res1)) {
46492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46493 }
46494 arg1 = reinterpret_cast< wxSizer * >(argp1);
46495 {
46496 PyThreadState* __tstate = wxPyBeginAllowThreads();
46497 result = (arg1)->CalcMin();
46498 wxPyEndAllowThreads(__tstate);
46499 if (PyErr_Occurred()) SWIG_fail;
46500 }
46501 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46502 return resultobj;
46503 fail:
46504 return NULL;
46505 }
46506
46507
46508 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46509 PyObject *resultobj = 0;
46510 wxSizer *arg1 = (wxSizer *) 0 ;
46511 void *argp1 = 0 ;
46512 int res1 = 0 ;
46513 PyObject *swig_obj[1] ;
46514
46515 if (!args) SWIG_fail;
46516 swig_obj[0] = args;
46517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizer * >(argp1);
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 (arg1)->Layout();
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 resultobj = SWIG_Py_Void();
46529 return resultobj;
46530 fail:
46531 return NULL;
46532 }
46533
46534
46535 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46536 PyObject *resultobj = 0;
46537 wxSizer *arg1 = (wxSizer *) 0 ;
46538 wxWindow *arg2 = (wxWindow *) 0 ;
46539 wxSize result;
46540 void *argp1 = 0 ;
46541 int res1 = 0 ;
46542 void *argp2 = 0 ;
46543 int res2 = 0 ;
46544 PyObject * obj0 = 0 ;
46545 PyObject * obj1 = 0 ;
46546 char * kwnames[] = {
46547 (char *) "self",(char *) "window", NULL
46548 };
46549
46550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46552 if (!SWIG_IsOK(res1)) {
46553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46554 }
46555 arg1 = reinterpret_cast< wxSizer * >(argp1);
46556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46557 if (!SWIG_IsOK(res2)) {
46558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46559 }
46560 arg2 = reinterpret_cast< wxWindow * >(argp2);
46561 {
46562 PyThreadState* __tstate = wxPyBeginAllowThreads();
46563 result = (arg1)->Fit(arg2);
46564 wxPyEndAllowThreads(__tstate);
46565 if (PyErr_Occurred()) SWIG_fail;
46566 }
46567 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46568 return resultobj;
46569 fail:
46570 return NULL;
46571 }
46572
46573
46574 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46575 PyObject *resultobj = 0;
46576 wxSizer *arg1 = (wxSizer *) 0 ;
46577 wxWindow *arg2 = (wxWindow *) 0 ;
46578 void *argp1 = 0 ;
46579 int res1 = 0 ;
46580 void *argp2 = 0 ;
46581 int res2 = 0 ;
46582 PyObject * obj0 = 0 ;
46583 PyObject * obj1 = 0 ;
46584 char * kwnames[] = {
46585 (char *) "self",(char *) "window", NULL
46586 };
46587
46588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46590 if (!SWIG_IsOK(res1)) {
46591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46592 }
46593 arg1 = reinterpret_cast< wxSizer * >(argp1);
46594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46595 if (!SWIG_IsOK(res2)) {
46596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46597 }
46598 arg2 = reinterpret_cast< wxWindow * >(argp2);
46599 {
46600 PyThreadState* __tstate = wxPyBeginAllowThreads();
46601 (arg1)->FitInside(arg2);
46602 wxPyEndAllowThreads(__tstate);
46603 if (PyErr_Occurred()) SWIG_fail;
46604 }
46605 resultobj = SWIG_Py_Void();
46606 return resultobj;
46607 fail:
46608 return NULL;
46609 }
46610
46611
46612 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46613 PyObject *resultobj = 0;
46614 wxSizer *arg1 = (wxSizer *) 0 ;
46615 wxWindow *arg2 = (wxWindow *) 0 ;
46616 void *argp1 = 0 ;
46617 int res1 = 0 ;
46618 void *argp2 = 0 ;
46619 int res2 = 0 ;
46620 PyObject * obj0 = 0 ;
46621 PyObject * obj1 = 0 ;
46622 char * kwnames[] = {
46623 (char *) "self",(char *) "window", NULL
46624 };
46625
46626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46628 if (!SWIG_IsOK(res1)) {
46629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46630 }
46631 arg1 = reinterpret_cast< wxSizer * >(argp1);
46632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46633 if (!SWIG_IsOK(res2)) {
46634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46635 }
46636 arg2 = reinterpret_cast< wxWindow * >(argp2);
46637 {
46638 PyThreadState* __tstate = wxPyBeginAllowThreads();
46639 (arg1)->SetSizeHints(arg2);
46640 wxPyEndAllowThreads(__tstate);
46641 if (PyErr_Occurred()) SWIG_fail;
46642 }
46643 resultobj = SWIG_Py_Void();
46644 return resultobj;
46645 fail:
46646 return NULL;
46647 }
46648
46649
46650 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46651 PyObject *resultobj = 0;
46652 wxSizer *arg1 = (wxSizer *) 0 ;
46653 wxWindow *arg2 = (wxWindow *) 0 ;
46654 void *argp1 = 0 ;
46655 int res1 = 0 ;
46656 void *argp2 = 0 ;
46657 int res2 = 0 ;
46658 PyObject * obj0 = 0 ;
46659 PyObject * obj1 = 0 ;
46660 char * kwnames[] = {
46661 (char *) "self",(char *) "window", NULL
46662 };
46663
46664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46666 if (!SWIG_IsOK(res1)) {
46667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46668 }
46669 arg1 = reinterpret_cast< wxSizer * >(argp1);
46670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46671 if (!SWIG_IsOK(res2)) {
46672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46673 }
46674 arg2 = reinterpret_cast< wxWindow * >(argp2);
46675 {
46676 PyThreadState* __tstate = wxPyBeginAllowThreads();
46677 (arg1)->SetVirtualSizeHints(arg2);
46678 wxPyEndAllowThreads(__tstate);
46679 if (PyErr_Occurred()) SWIG_fail;
46680 }
46681 resultobj = SWIG_Py_Void();
46682 return resultobj;
46683 fail:
46684 return NULL;
46685 }
46686
46687
46688 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46689 PyObject *resultobj = 0;
46690 wxSizer *arg1 = (wxSizer *) 0 ;
46691 bool arg2 = (bool) false ;
46692 void *argp1 = 0 ;
46693 int res1 = 0 ;
46694 bool val2 ;
46695 int ecode2 = 0 ;
46696 PyObject * obj0 = 0 ;
46697 PyObject * obj1 = 0 ;
46698 char * kwnames[] = {
46699 (char *) "self",(char *) "deleteWindows", NULL
46700 };
46701
46702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46704 if (!SWIG_IsOK(res1)) {
46705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46706 }
46707 arg1 = reinterpret_cast< wxSizer * >(argp1);
46708 if (obj1) {
46709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46710 if (!SWIG_IsOK(ecode2)) {
46711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46712 }
46713 arg2 = static_cast< bool >(val2);
46714 }
46715 {
46716 PyThreadState* __tstate = wxPyBeginAllowThreads();
46717 (arg1)->Clear(arg2);
46718 wxPyEndAllowThreads(__tstate);
46719 if (PyErr_Occurred()) SWIG_fail;
46720 }
46721 resultobj = SWIG_Py_Void();
46722 return resultobj;
46723 fail:
46724 return NULL;
46725 }
46726
46727
46728 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46729 PyObject *resultobj = 0;
46730 wxSizer *arg1 = (wxSizer *) 0 ;
46731 void *argp1 = 0 ;
46732 int res1 = 0 ;
46733 PyObject *swig_obj[1] ;
46734
46735 if (!args) SWIG_fail;
46736 swig_obj[0] = args;
46737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46738 if (!SWIG_IsOK(res1)) {
46739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46740 }
46741 arg1 = reinterpret_cast< wxSizer * >(argp1);
46742 {
46743 PyThreadState* __tstate = wxPyBeginAllowThreads();
46744 (arg1)->DeleteWindows();
46745 wxPyEndAllowThreads(__tstate);
46746 if (PyErr_Occurred()) SWIG_fail;
46747 }
46748 resultobj = SWIG_Py_Void();
46749 return resultobj;
46750 fail:
46751 return NULL;
46752 }
46753
46754
46755 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46756 PyObject *resultobj = 0;
46757 wxSizer *arg1 = (wxSizer *) 0 ;
46758 PyObject *result = 0 ;
46759 void *argp1 = 0 ;
46760 int res1 = 0 ;
46761 PyObject *swig_obj[1] ;
46762
46763 if (!args) SWIG_fail;
46764 swig_obj[0] = args;
46765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46766 if (!SWIG_IsOK(res1)) {
46767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46768 }
46769 arg1 = reinterpret_cast< wxSizer * >(argp1);
46770 {
46771 PyThreadState* __tstate = wxPyBeginAllowThreads();
46772 result = (PyObject *)wxSizer_GetChildren(arg1);
46773 wxPyEndAllowThreads(__tstate);
46774 if (PyErr_Occurred()) SWIG_fail;
46775 }
46776 resultobj = result;
46777 return resultobj;
46778 fail:
46779 return NULL;
46780 }
46781
46782
46783 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46784 PyObject *resultobj = 0;
46785 wxSizer *arg1 = (wxSizer *) 0 ;
46786 PyObject *arg2 = (PyObject *) 0 ;
46787 bool arg3 = (bool) true ;
46788 bool arg4 = (bool) false ;
46789 bool result;
46790 void *argp1 = 0 ;
46791 int res1 = 0 ;
46792 bool val3 ;
46793 int ecode3 = 0 ;
46794 bool val4 ;
46795 int ecode4 = 0 ;
46796 PyObject * obj0 = 0 ;
46797 PyObject * obj1 = 0 ;
46798 PyObject * obj2 = 0 ;
46799 PyObject * obj3 = 0 ;
46800 char * kwnames[] = {
46801 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46802 };
46803
46804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46806 if (!SWIG_IsOK(res1)) {
46807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46808 }
46809 arg1 = reinterpret_cast< wxSizer * >(argp1);
46810 arg2 = obj1;
46811 if (obj2) {
46812 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46813 if (!SWIG_IsOK(ecode3)) {
46814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46815 }
46816 arg3 = static_cast< bool >(val3);
46817 }
46818 if (obj3) {
46819 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46820 if (!SWIG_IsOK(ecode4)) {
46821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46822 }
46823 arg4 = static_cast< bool >(val4);
46824 }
46825 {
46826 PyThreadState* __tstate = wxPyBeginAllowThreads();
46827 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46828 wxPyEndAllowThreads(__tstate);
46829 if (PyErr_Occurred()) SWIG_fail;
46830 }
46831 {
46832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46833 }
46834 return resultobj;
46835 fail:
46836 return NULL;
46837 }
46838
46839
46840 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46841 PyObject *resultobj = 0;
46842 wxSizer *arg1 = (wxSizer *) 0 ;
46843 PyObject *arg2 = (PyObject *) 0 ;
46844 bool result;
46845 void *argp1 = 0 ;
46846 int res1 = 0 ;
46847 PyObject * obj0 = 0 ;
46848 PyObject * obj1 = 0 ;
46849 char * kwnames[] = {
46850 (char *) "self",(char *) "item", NULL
46851 };
46852
46853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46855 if (!SWIG_IsOK(res1)) {
46856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46857 }
46858 arg1 = reinterpret_cast< wxSizer * >(argp1);
46859 arg2 = obj1;
46860 {
46861 PyThreadState* __tstate = wxPyBeginAllowThreads();
46862 result = (bool)wxSizer_IsShown(arg1,arg2);
46863 wxPyEndAllowThreads(__tstate);
46864 if (PyErr_Occurred()) SWIG_fail;
46865 }
46866 {
46867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46868 }
46869 return resultobj;
46870 fail:
46871 return NULL;
46872 }
46873
46874
46875 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46876 PyObject *resultobj = 0;
46877 wxSizer *arg1 = (wxSizer *) 0 ;
46878 bool arg2 ;
46879 void *argp1 = 0 ;
46880 int res1 = 0 ;
46881 bool val2 ;
46882 int ecode2 = 0 ;
46883 PyObject * obj0 = 0 ;
46884 PyObject * obj1 = 0 ;
46885 char * kwnames[] = {
46886 (char *) "self",(char *) "show", NULL
46887 };
46888
46889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
46890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46891 if (!SWIG_IsOK(res1)) {
46892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
46893 }
46894 arg1 = reinterpret_cast< wxSizer * >(argp1);
46895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46896 if (!SWIG_IsOK(ecode2)) {
46897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
46898 }
46899 arg2 = static_cast< bool >(val2);
46900 {
46901 PyThreadState* __tstate = wxPyBeginAllowThreads();
46902 (arg1)->ShowItems(arg2);
46903 wxPyEndAllowThreads(__tstate);
46904 if (PyErr_Occurred()) SWIG_fail;
46905 }
46906 resultobj = SWIG_Py_Void();
46907 return resultobj;
46908 fail:
46909 return NULL;
46910 }
46911
46912
46913 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46914 PyObject *obj;
46915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46916 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
46917 return SWIG_Py_Void();
46918 }
46919
46920 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46921 PyObject *resultobj = 0;
46922 wxPySizer *result = 0 ;
46923
46924 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
46925 {
46926 PyThreadState* __tstate = wxPyBeginAllowThreads();
46927 result = (wxPySizer *)new wxPySizer();
46928 wxPyEndAllowThreads(__tstate);
46929 if (PyErr_Occurred()) SWIG_fail;
46930 }
46931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
46932 return resultobj;
46933 fail:
46934 return NULL;
46935 }
46936
46937
46938 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46939 PyObject *resultobj = 0;
46940 wxPySizer *arg1 = (wxPySizer *) 0 ;
46941 PyObject *arg2 = (PyObject *) 0 ;
46942 PyObject *arg3 = (PyObject *) 0 ;
46943 void *argp1 = 0 ;
46944 int res1 = 0 ;
46945 PyObject * obj0 = 0 ;
46946 PyObject * obj1 = 0 ;
46947 PyObject * obj2 = 0 ;
46948 char * kwnames[] = {
46949 (char *) "self",(char *) "self",(char *) "_class", NULL
46950 };
46951
46952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
46954 if (!SWIG_IsOK(res1)) {
46955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
46956 }
46957 arg1 = reinterpret_cast< wxPySizer * >(argp1);
46958 arg2 = obj1;
46959 arg3 = obj2;
46960 {
46961 PyThreadState* __tstate = wxPyBeginAllowThreads();
46962 (arg1)->_setCallbackInfo(arg2,arg3);
46963 wxPyEndAllowThreads(__tstate);
46964 if (PyErr_Occurred()) SWIG_fail;
46965 }
46966 resultobj = SWIG_Py_Void();
46967 return resultobj;
46968 fail:
46969 return NULL;
46970 }
46971
46972
46973 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46974 PyObject *obj;
46975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46976 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
46977 return SWIG_Py_Void();
46978 }
46979
46980 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46981 return SWIG_Python_InitShadowInstance(args);
46982 }
46983
46984 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46985 PyObject *resultobj = 0;
46986 int arg1 = (int) wxHORIZONTAL ;
46987 wxBoxSizer *result = 0 ;
46988 int val1 ;
46989 int ecode1 = 0 ;
46990 PyObject * obj0 = 0 ;
46991 char * kwnames[] = {
46992 (char *) "orient", NULL
46993 };
46994
46995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
46996 if (obj0) {
46997 ecode1 = SWIG_AsVal_int(obj0, &val1);
46998 if (!SWIG_IsOK(ecode1)) {
46999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47000 }
47001 arg1 = static_cast< int >(val1);
47002 }
47003 {
47004 PyThreadState* __tstate = wxPyBeginAllowThreads();
47005 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47017 PyObject *resultobj = 0;
47018 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47019 int result;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 PyObject *swig_obj[1] ;
47023
47024 if (!args) SWIG_fail;
47025 swig_obj[0] = args;
47026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47027 if (!SWIG_IsOK(res1)) {
47028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47029 }
47030 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47031 {
47032 PyThreadState* __tstate = wxPyBeginAllowThreads();
47033 result = (int)(arg1)->GetOrientation();
47034 wxPyEndAllowThreads(__tstate);
47035 if (PyErr_Occurred()) SWIG_fail;
47036 }
47037 resultobj = SWIG_From_int(static_cast< int >(result));
47038 return resultobj;
47039 fail:
47040 return NULL;
47041 }
47042
47043
47044 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47045 PyObject *resultobj = 0;
47046 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47047 int arg2 ;
47048 void *argp1 = 0 ;
47049 int res1 = 0 ;
47050 int val2 ;
47051 int ecode2 = 0 ;
47052 PyObject * obj0 = 0 ;
47053 PyObject * obj1 = 0 ;
47054 char * kwnames[] = {
47055 (char *) "self",(char *) "orient", NULL
47056 };
47057
47058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47060 if (!SWIG_IsOK(res1)) {
47061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47062 }
47063 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47064 ecode2 = SWIG_AsVal_int(obj1, &val2);
47065 if (!SWIG_IsOK(ecode2)) {
47066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47067 }
47068 arg2 = static_cast< int >(val2);
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 (arg1)->SetOrientation(arg2);
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 resultobj = SWIG_Py_Void();
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47083 PyObject *obj;
47084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47085 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47086 return SWIG_Py_Void();
47087 }
47088
47089 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47090 return SWIG_Python_InitShadowInstance(args);
47091 }
47092
47093 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47094 PyObject *resultobj = 0;
47095 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47096 int arg2 = (int) wxHORIZONTAL ;
47097 wxStaticBoxSizer *result = 0 ;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 int val2 ;
47101 int ecode2 = 0 ;
47102 PyObject * obj0 = 0 ;
47103 PyObject * obj1 = 0 ;
47104 char * kwnames[] = {
47105 (char *) "box",(char *) "orient", NULL
47106 };
47107
47108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47110 if (!SWIG_IsOK(res1)) {
47111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47112 }
47113 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47114 if (obj1) {
47115 ecode2 = SWIG_AsVal_int(obj1, &val2);
47116 if (!SWIG_IsOK(ecode2)) {
47117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47118 }
47119 arg2 = static_cast< int >(val2);
47120 }
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47124 wxPyEndAllowThreads(__tstate);
47125 if (PyErr_Occurred()) SWIG_fail;
47126 }
47127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47128 return resultobj;
47129 fail:
47130 return NULL;
47131 }
47132
47133
47134 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47135 PyObject *resultobj = 0;
47136 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47137 wxStaticBox *result = 0 ;
47138 void *argp1 = 0 ;
47139 int res1 = 0 ;
47140 PyObject *swig_obj[1] ;
47141
47142 if (!args) SWIG_fail;
47143 swig_obj[0] = args;
47144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47145 if (!SWIG_IsOK(res1)) {
47146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47147 }
47148 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47149 {
47150 PyThreadState* __tstate = wxPyBeginAllowThreads();
47151 result = (wxStaticBox *)(arg1)->GetStaticBox();
47152 wxPyEndAllowThreads(__tstate);
47153 if (PyErr_Occurred()) SWIG_fail;
47154 }
47155 {
47156 resultobj = wxPyMake_wxObject(result, (bool)0);
47157 }
47158 return resultobj;
47159 fail:
47160 return NULL;
47161 }
47162
47163
47164 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47165 PyObject *obj;
47166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47167 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47168 return SWIG_Py_Void();
47169 }
47170
47171 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47172 return SWIG_Python_InitShadowInstance(args);
47173 }
47174
47175 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 int arg1 = (int) 1 ;
47178 int arg2 = (int) 0 ;
47179 int arg3 = (int) 0 ;
47180 int arg4 = (int) 0 ;
47181 wxGridSizer *result = 0 ;
47182 int val1 ;
47183 int ecode1 = 0 ;
47184 int val2 ;
47185 int ecode2 = 0 ;
47186 int val3 ;
47187 int ecode3 = 0 ;
47188 int val4 ;
47189 int ecode4 = 0 ;
47190 PyObject * obj0 = 0 ;
47191 PyObject * obj1 = 0 ;
47192 PyObject * obj2 = 0 ;
47193 PyObject * obj3 = 0 ;
47194 char * kwnames[] = {
47195 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47196 };
47197
47198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47199 if (obj0) {
47200 ecode1 = SWIG_AsVal_int(obj0, &val1);
47201 if (!SWIG_IsOK(ecode1)) {
47202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47203 }
47204 arg1 = static_cast< int >(val1);
47205 }
47206 if (obj1) {
47207 ecode2 = SWIG_AsVal_int(obj1, &val2);
47208 if (!SWIG_IsOK(ecode2)) {
47209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47210 }
47211 arg2 = static_cast< int >(val2);
47212 }
47213 if (obj2) {
47214 ecode3 = SWIG_AsVal_int(obj2, &val3);
47215 if (!SWIG_IsOK(ecode3)) {
47216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47217 }
47218 arg3 = static_cast< int >(val3);
47219 }
47220 if (obj3) {
47221 ecode4 = SWIG_AsVal_int(obj3, &val4);
47222 if (!SWIG_IsOK(ecode4)) {
47223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47224 }
47225 arg4 = static_cast< int >(val4);
47226 }
47227 {
47228 PyThreadState* __tstate = wxPyBeginAllowThreads();
47229 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47230 wxPyEndAllowThreads(__tstate);
47231 if (PyErr_Occurred()) SWIG_fail;
47232 }
47233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47234 return resultobj;
47235 fail:
47236 return NULL;
47237 }
47238
47239
47240 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47241 PyObject *resultobj = 0;
47242 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47243 int arg2 ;
47244 void *argp1 = 0 ;
47245 int res1 = 0 ;
47246 int val2 ;
47247 int ecode2 = 0 ;
47248 PyObject * obj0 = 0 ;
47249 PyObject * obj1 = 0 ;
47250 char * kwnames[] = {
47251 (char *) "self",(char *) "cols", NULL
47252 };
47253
47254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47256 if (!SWIG_IsOK(res1)) {
47257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47258 }
47259 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47260 ecode2 = SWIG_AsVal_int(obj1, &val2);
47261 if (!SWIG_IsOK(ecode2)) {
47262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47263 }
47264 arg2 = static_cast< int >(val2);
47265 {
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 (arg1)->SetCols(arg2);
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 resultobj = SWIG_Py_Void();
47272 return resultobj;
47273 fail:
47274 return NULL;
47275 }
47276
47277
47278 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47279 PyObject *resultobj = 0;
47280 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47281 int arg2 ;
47282 void *argp1 = 0 ;
47283 int res1 = 0 ;
47284 int val2 ;
47285 int ecode2 = 0 ;
47286 PyObject * obj0 = 0 ;
47287 PyObject * obj1 = 0 ;
47288 char * kwnames[] = {
47289 (char *) "self",(char *) "rows", NULL
47290 };
47291
47292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47294 if (!SWIG_IsOK(res1)) {
47295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47296 }
47297 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47298 ecode2 = SWIG_AsVal_int(obj1, &val2);
47299 if (!SWIG_IsOK(ecode2)) {
47300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47301 }
47302 arg2 = static_cast< int >(val2);
47303 {
47304 PyThreadState* __tstate = wxPyBeginAllowThreads();
47305 (arg1)->SetRows(arg2);
47306 wxPyEndAllowThreads(__tstate);
47307 if (PyErr_Occurred()) SWIG_fail;
47308 }
47309 resultobj = SWIG_Py_Void();
47310 return resultobj;
47311 fail:
47312 return NULL;
47313 }
47314
47315
47316 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47317 PyObject *resultobj = 0;
47318 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47319 int arg2 ;
47320 void *argp1 = 0 ;
47321 int res1 = 0 ;
47322 int val2 ;
47323 int ecode2 = 0 ;
47324 PyObject * obj0 = 0 ;
47325 PyObject * obj1 = 0 ;
47326 char * kwnames[] = {
47327 (char *) "self",(char *) "gap", NULL
47328 };
47329
47330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47332 if (!SWIG_IsOK(res1)) {
47333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47334 }
47335 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47336 ecode2 = SWIG_AsVal_int(obj1, &val2);
47337 if (!SWIG_IsOK(ecode2)) {
47338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47339 }
47340 arg2 = static_cast< int >(val2);
47341 {
47342 PyThreadState* __tstate = wxPyBeginAllowThreads();
47343 (arg1)->SetVGap(arg2);
47344 wxPyEndAllowThreads(__tstate);
47345 if (PyErr_Occurred()) SWIG_fail;
47346 }
47347 resultobj = SWIG_Py_Void();
47348 return resultobj;
47349 fail:
47350 return NULL;
47351 }
47352
47353
47354 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47355 PyObject *resultobj = 0;
47356 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47357 int arg2 ;
47358 void *argp1 = 0 ;
47359 int res1 = 0 ;
47360 int val2 ;
47361 int ecode2 = 0 ;
47362 PyObject * obj0 = 0 ;
47363 PyObject * obj1 = 0 ;
47364 char * kwnames[] = {
47365 (char *) "self",(char *) "gap", NULL
47366 };
47367
47368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47372 }
47373 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47374 ecode2 = SWIG_AsVal_int(obj1, &val2);
47375 if (!SWIG_IsOK(ecode2)) {
47376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47377 }
47378 arg2 = static_cast< int >(val2);
47379 {
47380 PyThreadState* __tstate = wxPyBeginAllowThreads();
47381 (arg1)->SetHGap(arg2);
47382 wxPyEndAllowThreads(__tstate);
47383 if (PyErr_Occurred()) SWIG_fail;
47384 }
47385 resultobj = SWIG_Py_Void();
47386 return resultobj;
47387 fail:
47388 return NULL;
47389 }
47390
47391
47392 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47393 PyObject *resultobj = 0;
47394 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47395 int result;
47396 void *argp1 = 0 ;
47397 int res1 = 0 ;
47398 PyObject *swig_obj[1] ;
47399
47400 if (!args) SWIG_fail;
47401 swig_obj[0] = args;
47402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47403 if (!SWIG_IsOK(res1)) {
47404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47405 }
47406 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47407 {
47408 PyThreadState* __tstate = wxPyBeginAllowThreads();
47409 result = (int)(arg1)->GetCols();
47410 wxPyEndAllowThreads(__tstate);
47411 if (PyErr_Occurred()) SWIG_fail;
47412 }
47413 resultobj = SWIG_From_int(static_cast< int >(result));
47414 return resultobj;
47415 fail:
47416 return NULL;
47417 }
47418
47419
47420 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47421 PyObject *resultobj = 0;
47422 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47423 int result;
47424 void *argp1 = 0 ;
47425 int res1 = 0 ;
47426 PyObject *swig_obj[1] ;
47427
47428 if (!args) SWIG_fail;
47429 swig_obj[0] = args;
47430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47431 if (!SWIG_IsOK(res1)) {
47432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47433 }
47434 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47435 {
47436 PyThreadState* __tstate = wxPyBeginAllowThreads();
47437 result = (int)(arg1)->GetRows();
47438 wxPyEndAllowThreads(__tstate);
47439 if (PyErr_Occurred()) SWIG_fail;
47440 }
47441 resultobj = SWIG_From_int(static_cast< int >(result));
47442 return resultobj;
47443 fail:
47444 return NULL;
47445 }
47446
47447
47448 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47449 PyObject *resultobj = 0;
47450 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47451 int result;
47452 void *argp1 = 0 ;
47453 int res1 = 0 ;
47454 PyObject *swig_obj[1] ;
47455
47456 if (!args) SWIG_fail;
47457 swig_obj[0] = args;
47458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47459 if (!SWIG_IsOK(res1)) {
47460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47461 }
47462 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47463 {
47464 PyThreadState* __tstate = wxPyBeginAllowThreads();
47465 result = (int)(arg1)->GetVGap();
47466 wxPyEndAllowThreads(__tstate);
47467 if (PyErr_Occurred()) SWIG_fail;
47468 }
47469 resultobj = SWIG_From_int(static_cast< int >(result));
47470 return resultobj;
47471 fail:
47472 return NULL;
47473 }
47474
47475
47476 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47477 PyObject *resultobj = 0;
47478 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47479 int result;
47480 void *argp1 = 0 ;
47481 int res1 = 0 ;
47482 PyObject *swig_obj[1] ;
47483
47484 if (!args) SWIG_fail;
47485 swig_obj[0] = args;
47486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47487 if (!SWIG_IsOK(res1)) {
47488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47489 }
47490 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47491 {
47492 PyThreadState* __tstate = wxPyBeginAllowThreads();
47493 result = (int)(arg1)->GetHGap();
47494 wxPyEndAllowThreads(__tstate);
47495 if (PyErr_Occurred()) SWIG_fail;
47496 }
47497 resultobj = SWIG_From_int(static_cast< int >(result));
47498 return resultobj;
47499 fail:
47500 return NULL;
47501 }
47502
47503
47504 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47505 PyObject *obj;
47506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47507 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47508 return SWIG_Py_Void();
47509 }
47510
47511 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47512 return SWIG_Python_InitShadowInstance(args);
47513 }
47514
47515 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47516 PyObject *resultobj = 0;
47517 int arg1 = (int) 1 ;
47518 int arg2 = (int) 0 ;
47519 int arg3 = (int) 0 ;
47520 int arg4 = (int) 0 ;
47521 wxFlexGridSizer *result = 0 ;
47522 int val1 ;
47523 int ecode1 = 0 ;
47524 int val2 ;
47525 int ecode2 = 0 ;
47526 int val3 ;
47527 int ecode3 = 0 ;
47528 int val4 ;
47529 int ecode4 = 0 ;
47530 PyObject * obj0 = 0 ;
47531 PyObject * obj1 = 0 ;
47532 PyObject * obj2 = 0 ;
47533 PyObject * obj3 = 0 ;
47534 char * kwnames[] = {
47535 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47536 };
47537
47538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47539 if (obj0) {
47540 ecode1 = SWIG_AsVal_int(obj0, &val1);
47541 if (!SWIG_IsOK(ecode1)) {
47542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47543 }
47544 arg1 = static_cast< int >(val1);
47545 }
47546 if (obj1) {
47547 ecode2 = SWIG_AsVal_int(obj1, &val2);
47548 if (!SWIG_IsOK(ecode2)) {
47549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47550 }
47551 arg2 = static_cast< int >(val2);
47552 }
47553 if (obj2) {
47554 ecode3 = SWIG_AsVal_int(obj2, &val3);
47555 if (!SWIG_IsOK(ecode3)) {
47556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47557 }
47558 arg3 = static_cast< int >(val3);
47559 }
47560 if (obj3) {
47561 ecode4 = SWIG_AsVal_int(obj3, &val4);
47562 if (!SWIG_IsOK(ecode4)) {
47563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47564 }
47565 arg4 = static_cast< int >(val4);
47566 }
47567 {
47568 PyThreadState* __tstate = wxPyBeginAllowThreads();
47569 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47570 wxPyEndAllowThreads(__tstate);
47571 if (PyErr_Occurred()) SWIG_fail;
47572 }
47573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47574 return resultobj;
47575 fail:
47576 return NULL;
47577 }
47578
47579
47580 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47581 PyObject *resultobj = 0;
47582 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47583 size_t arg2 ;
47584 int arg3 = (int) 0 ;
47585 void *argp1 = 0 ;
47586 int res1 = 0 ;
47587 size_t val2 ;
47588 int ecode2 = 0 ;
47589 int val3 ;
47590 int ecode3 = 0 ;
47591 PyObject * obj0 = 0 ;
47592 PyObject * obj1 = 0 ;
47593 PyObject * obj2 = 0 ;
47594 char * kwnames[] = {
47595 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47596 };
47597
47598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47600 if (!SWIG_IsOK(res1)) {
47601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47602 }
47603 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47604 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47605 if (!SWIG_IsOK(ecode2)) {
47606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47607 }
47608 arg2 = static_cast< size_t >(val2);
47609 if (obj2) {
47610 ecode3 = SWIG_AsVal_int(obj2, &val3);
47611 if (!SWIG_IsOK(ecode3)) {
47612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47613 }
47614 arg3 = static_cast< int >(val3);
47615 }
47616 {
47617 PyThreadState* __tstate = wxPyBeginAllowThreads();
47618 (arg1)->AddGrowableRow(arg2,arg3);
47619 wxPyEndAllowThreads(__tstate);
47620 if (PyErr_Occurred()) SWIG_fail;
47621 }
47622 resultobj = SWIG_Py_Void();
47623 return resultobj;
47624 fail:
47625 return NULL;
47626 }
47627
47628
47629 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47630 PyObject *resultobj = 0;
47631 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47632 size_t arg2 ;
47633 void *argp1 = 0 ;
47634 int res1 = 0 ;
47635 size_t val2 ;
47636 int ecode2 = 0 ;
47637 PyObject * obj0 = 0 ;
47638 PyObject * obj1 = 0 ;
47639 char * kwnames[] = {
47640 (char *) "self",(char *) "idx", NULL
47641 };
47642
47643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47645 if (!SWIG_IsOK(res1)) {
47646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47647 }
47648 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47649 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47650 if (!SWIG_IsOK(ecode2)) {
47651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47652 }
47653 arg2 = static_cast< size_t >(val2);
47654 {
47655 PyThreadState* __tstate = wxPyBeginAllowThreads();
47656 (arg1)->RemoveGrowableRow(arg2);
47657 wxPyEndAllowThreads(__tstate);
47658 if (PyErr_Occurred()) SWIG_fail;
47659 }
47660 resultobj = SWIG_Py_Void();
47661 return resultobj;
47662 fail:
47663 return NULL;
47664 }
47665
47666
47667 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47668 PyObject *resultobj = 0;
47669 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47670 size_t arg2 ;
47671 int arg3 = (int) 0 ;
47672 void *argp1 = 0 ;
47673 int res1 = 0 ;
47674 size_t val2 ;
47675 int ecode2 = 0 ;
47676 int val3 ;
47677 int ecode3 = 0 ;
47678 PyObject * obj0 = 0 ;
47679 PyObject * obj1 = 0 ;
47680 PyObject * obj2 = 0 ;
47681 char * kwnames[] = {
47682 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47683 };
47684
47685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47687 if (!SWIG_IsOK(res1)) {
47688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47689 }
47690 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47691 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47692 if (!SWIG_IsOK(ecode2)) {
47693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47694 }
47695 arg2 = static_cast< size_t >(val2);
47696 if (obj2) {
47697 ecode3 = SWIG_AsVal_int(obj2, &val3);
47698 if (!SWIG_IsOK(ecode3)) {
47699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47700 }
47701 arg3 = static_cast< int >(val3);
47702 }
47703 {
47704 PyThreadState* __tstate = wxPyBeginAllowThreads();
47705 (arg1)->AddGrowableCol(arg2,arg3);
47706 wxPyEndAllowThreads(__tstate);
47707 if (PyErr_Occurred()) SWIG_fail;
47708 }
47709 resultobj = SWIG_Py_Void();
47710 return resultobj;
47711 fail:
47712 return NULL;
47713 }
47714
47715
47716 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47717 PyObject *resultobj = 0;
47718 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47719 size_t arg2 ;
47720 void *argp1 = 0 ;
47721 int res1 = 0 ;
47722 size_t val2 ;
47723 int ecode2 = 0 ;
47724 PyObject * obj0 = 0 ;
47725 PyObject * obj1 = 0 ;
47726 char * kwnames[] = {
47727 (char *) "self",(char *) "idx", NULL
47728 };
47729
47730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47732 if (!SWIG_IsOK(res1)) {
47733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47734 }
47735 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47736 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47737 if (!SWIG_IsOK(ecode2)) {
47738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47739 }
47740 arg2 = static_cast< size_t >(val2);
47741 {
47742 PyThreadState* __tstate = wxPyBeginAllowThreads();
47743 (arg1)->RemoveGrowableCol(arg2);
47744 wxPyEndAllowThreads(__tstate);
47745 if (PyErr_Occurred()) SWIG_fail;
47746 }
47747 resultobj = SWIG_Py_Void();
47748 return resultobj;
47749 fail:
47750 return NULL;
47751 }
47752
47753
47754 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47755 PyObject *resultobj = 0;
47756 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47757 int arg2 ;
47758 void *argp1 = 0 ;
47759 int res1 = 0 ;
47760 int val2 ;
47761 int ecode2 = 0 ;
47762 PyObject * obj0 = 0 ;
47763 PyObject * obj1 = 0 ;
47764 char * kwnames[] = {
47765 (char *) "self",(char *) "direction", NULL
47766 };
47767
47768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47770 if (!SWIG_IsOK(res1)) {
47771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47772 }
47773 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47774 ecode2 = SWIG_AsVal_int(obj1, &val2);
47775 if (!SWIG_IsOK(ecode2)) {
47776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47777 }
47778 arg2 = static_cast< int >(val2);
47779 {
47780 PyThreadState* __tstate = wxPyBeginAllowThreads();
47781 (arg1)->SetFlexibleDirection(arg2);
47782 wxPyEndAllowThreads(__tstate);
47783 if (PyErr_Occurred()) SWIG_fail;
47784 }
47785 resultobj = SWIG_Py_Void();
47786 return resultobj;
47787 fail:
47788 return NULL;
47789 }
47790
47791
47792 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47793 PyObject *resultobj = 0;
47794 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47795 int result;
47796 void *argp1 = 0 ;
47797 int res1 = 0 ;
47798 PyObject *swig_obj[1] ;
47799
47800 if (!args) SWIG_fail;
47801 swig_obj[0] = args;
47802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47803 if (!SWIG_IsOK(res1)) {
47804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47805 }
47806 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47807 {
47808 PyThreadState* __tstate = wxPyBeginAllowThreads();
47809 result = (int)(arg1)->GetFlexibleDirection();
47810 wxPyEndAllowThreads(__tstate);
47811 if (PyErr_Occurred()) SWIG_fail;
47812 }
47813 resultobj = SWIG_From_int(static_cast< int >(result));
47814 return resultobj;
47815 fail:
47816 return NULL;
47817 }
47818
47819
47820 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47821 PyObject *resultobj = 0;
47822 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47823 wxFlexSizerGrowMode arg2 ;
47824 void *argp1 = 0 ;
47825 int res1 = 0 ;
47826 int val2 ;
47827 int ecode2 = 0 ;
47828 PyObject * obj0 = 0 ;
47829 PyObject * obj1 = 0 ;
47830 char * kwnames[] = {
47831 (char *) "self",(char *) "mode", NULL
47832 };
47833
47834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47836 if (!SWIG_IsOK(res1)) {
47837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47838 }
47839 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47840 ecode2 = SWIG_AsVal_int(obj1, &val2);
47841 if (!SWIG_IsOK(ecode2)) {
47842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47843 }
47844 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47845 {
47846 PyThreadState* __tstate = wxPyBeginAllowThreads();
47847 (arg1)->SetNonFlexibleGrowMode(arg2);
47848 wxPyEndAllowThreads(__tstate);
47849 if (PyErr_Occurred()) SWIG_fail;
47850 }
47851 resultobj = SWIG_Py_Void();
47852 return resultobj;
47853 fail:
47854 return NULL;
47855 }
47856
47857
47858 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47859 PyObject *resultobj = 0;
47860 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47861 wxFlexSizerGrowMode result;
47862 void *argp1 = 0 ;
47863 int res1 = 0 ;
47864 PyObject *swig_obj[1] ;
47865
47866 if (!args) SWIG_fail;
47867 swig_obj[0] = args;
47868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47869 if (!SWIG_IsOK(res1)) {
47870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47871 }
47872 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47873 {
47874 PyThreadState* __tstate = wxPyBeginAllowThreads();
47875 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
47876 wxPyEndAllowThreads(__tstate);
47877 if (PyErr_Occurred()) SWIG_fail;
47878 }
47879 resultobj = SWIG_From_int(static_cast< int >(result));
47880 return resultobj;
47881 fail:
47882 return NULL;
47883 }
47884
47885
47886 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47887 PyObject *resultobj = 0;
47888 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47889 wxArrayInt *result = 0 ;
47890 void *argp1 = 0 ;
47891 int res1 = 0 ;
47892 PyObject *swig_obj[1] ;
47893
47894 if (!args) SWIG_fail;
47895 swig_obj[0] = args;
47896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47897 if (!SWIG_IsOK(res1)) {
47898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
47899 }
47900 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47901 {
47902 PyThreadState* __tstate = wxPyBeginAllowThreads();
47903 {
47904 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
47905 result = (wxArrayInt *) &_result_ref;
47906 }
47907 wxPyEndAllowThreads(__tstate);
47908 if (PyErr_Occurred()) SWIG_fail;
47909 }
47910 {
47911 resultobj = PyList_New(0);
47912 size_t idx;
47913 for (idx = 0; idx < result->GetCount(); idx += 1) {
47914 PyObject* val = PyInt_FromLong( result->Item(idx) );
47915 PyList_Append(resultobj, val);
47916 Py_DECREF(val);
47917 }
47918 }
47919 return resultobj;
47920 fail:
47921 return NULL;
47922 }
47923
47924
47925 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47926 PyObject *resultobj = 0;
47927 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47928 wxArrayInt *result = 0 ;
47929 void *argp1 = 0 ;
47930 int res1 = 0 ;
47931 PyObject *swig_obj[1] ;
47932
47933 if (!args) SWIG_fail;
47934 swig_obj[0] = args;
47935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47936 if (!SWIG_IsOK(res1)) {
47937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
47938 }
47939 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47940 {
47941 PyThreadState* __tstate = wxPyBeginAllowThreads();
47942 {
47943 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
47944 result = (wxArrayInt *) &_result_ref;
47945 }
47946 wxPyEndAllowThreads(__tstate);
47947 if (PyErr_Occurred()) SWIG_fail;
47948 }
47949 {
47950 resultobj = PyList_New(0);
47951 size_t idx;
47952 for (idx = 0; idx < result->GetCount(); idx += 1) {
47953 PyObject* val = PyInt_FromLong( result->Item(idx) );
47954 PyList_Append(resultobj, val);
47955 Py_DECREF(val);
47956 }
47957 }
47958 return resultobj;
47959 fail:
47960 return NULL;
47961 }
47962
47963
47964 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47965 PyObject *obj;
47966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47967 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
47968 return SWIG_Py_Void();
47969 }
47970
47971 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47972 return SWIG_Python_InitShadowInstance(args);
47973 }
47974
47975 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47976 PyObject *resultobj = 0;
47977 wxStdDialogButtonSizer *result = 0 ;
47978
47979 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
47980 {
47981 PyThreadState* __tstate = wxPyBeginAllowThreads();
47982 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
47983 wxPyEndAllowThreads(__tstate);
47984 if (PyErr_Occurred()) SWIG_fail;
47985 }
47986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
47987 return resultobj;
47988 fail:
47989 return NULL;
47990 }
47991
47992
47993 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47994 PyObject *resultobj = 0;
47995 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
47996 wxButton *arg2 = (wxButton *) 0 ;
47997 void *argp1 = 0 ;
47998 int res1 = 0 ;
47999 void *argp2 = 0 ;
48000 int res2 = 0 ;
48001 PyObject * obj0 = 0 ;
48002 PyObject * obj1 = 0 ;
48003 char * kwnames[] = {
48004 (char *) "self",(char *) "button", NULL
48005 };
48006
48007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48009 if (!SWIG_IsOK(res1)) {
48010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48011 }
48012 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48014 if (!SWIG_IsOK(res2)) {
48015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48016 }
48017 arg2 = reinterpret_cast< wxButton * >(argp2);
48018 {
48019 PyThreadState* __tstate = wxPyBeginAllowThreads();
48020 (arg1)->AddButton(arg2);
48021 wxPyEndAllowThreads(__tstate);
48022 if (PyErr_Occurred()) SWIG_fail;
48023 }
48024 resultobj = SWIG_Py_Void();
48025 return resultobj;
48026 fail:
48027 return NULL;
48028 }
48029
48030
48031 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48032 PyObject *resultobj = 0;
48033 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48034 void *argp1 = 0 ;
48035 int res1 = 0 ;
48036 PyObject *swig_obj[1] ;
48037
48038 if (!args) SWIG_fail;
48039 swig_obj[0] = args;
48040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48041 if (!SWIG_IsOK(res1)) {
48042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48043 }
48044 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48045 {
48046 PyThreadState* __tstate = wxPyBeginAllowThreads();
48047 (arg1)->Realize();
48048 wxPyEndAllowThreads(__tstate);
48049 if (PyErr_Occurred()) SWIG_fail;
48050 }
48051 resultobj = SWIG_Py_Void();
48052 return resultobj;
48053 fail:
48054 return NULL;
48055 }
48056
48057
48058 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48059 PyObject *resultobj = 0;
48060 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48061 wxButton *arg2 = (wxButton *) 0 ;
48062 void *argp1 = 0 ;
48063 int res1 = 0 ;
48064 void *argp2 = 0 ;
48065 int res2 = 0 ;
48066 PyObject * obj0 = 0 ;
48067 PyObject * obj1 = 0 ;
48068 char * kwnames[] = {
48069 (char *) "self",(char *) "button", NULL
48070 };
48071
48072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48074 if (!SWIG_IsOK(res1)) {
48075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48076 }
48077 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48078 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48079 if (!SWIG_IsOK(res2)) {
48080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48081 }
48082 arg2 = reinterpret_cast< wxButton * >(argp2);
48083 {
48084 PyThreadState* __tstate = wxPyBeginAllowThreads();
48085 (arg1)->SetAffirmativeButton(arg2);
48086 wxPyEndAllowThreads(__tstate);
48087 if (PyErr_Occurred()) SWIG_fail;
48088 }
48089 resultobj = SWIG_Py_Void();
48090 return resultobj;
48091 fail:
48092 return NULL;
48093 }
48094
48095
48096 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48097 PyObject *resultobj = 0;
48098 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48099 wxButton *arg2 = (wxButton *) 0 ;
48100 void *argp1 = 0 ;
48101 int res1 = 0 ;
48102 void *argp2 = 0 ;
48103 int res2 = 0 ;
48104 PyObject * obj0 = 0 ;
48105 PyObject * obj1 = 0 ;
48106 char * kwnames[] = {
48107 (char *) "self",(char *) "button", NULL
48108 };
48109
48110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48112 if (!SWIG_IsOK(res1)) {
48113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48114 }
48115 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48117 if (!SWIG_IsOK(res2)) {
48118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48119 }
48120 arg2 = reinterpret_cast< wxButton * >(argp2);
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 (arg1)->SetNegativeButton(arg2);
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_Py_Void();
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48135 PyObject *resultobj = 0;
48136 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48137 wxButton *arg2 = (wxButton *) 0 ;
48138 void *argp1 = 0 ;
48139 int res1 = 0 ;
48140 void *argp2 = 0 ;
48141 int res2 = 0 ;
48142 PyObject * obj0 = 0 ;
48143 PyObject * obj1 = 0 ;
48144 char * kwnames[] = {
48145 (char *) "self",(char *) "button", NULL
48146 };
48147
48148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48150 if (!SWIG_IsOK(res1)) {
48151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48152 }
48153 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48155 if (!SWIG_IsOK(res2)) {
48156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48157 }
48158 arg2 = reinterpret_cast< wxButton * >(argp2);
48159 {
48160 PyThreadState* __tstate = wxPyBeginAllowThreads();
48161 (arg1)->SetCancelButton(arg2);
48162 wxPyEndAllowThreads(__tstate);
48163 if (PyErr_Occurred()) SWIG_fail;
48164 }
48165 resultobj = SWIG_Py_Void();
48166 return resultobj;
48167 fail:
48168 return NULL;
48169 }
48170
48171
48172 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48173 PyObject *resultobj = 0;
48174 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48175 wxButton *result = 0 ;
48176 void *argp1 = 0 ;
48177 int res1 = 0 ;
48178 PyObject *swig_obj[1] ;
48179
48180 if (!args) SWIG_fail;
48181 swig_obj[0] = args;
48182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48183 if (!SWIG_IsOK(res1)) {
48184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48185 }
48186 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48187 {
48188 PyThreadState* __tstate = wxPyBeginAllowThreads();
48189 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48190 wxPyEndAllowThreads(__tstate);
48191 if (PyErr_Occurred()) SWIG_fail;
48192 }
48193 {
48194 resultobj = wxPyMake_wxObject(result, (bool)0);
48195 }
48196 return resultobj;
48197 fail:
48198 return NULL;
48199 }
48200
48201
48202 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48203 PyObject *resultobj = 0;
48204 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48205 wxButton *result = 0 ;
48206 void *argp1 = 0 ;
48207 int res1 = 0 ;
48208 PyObject *swig_obj[1] ;
48209
48210 if (!args) SWIG_fail;
48211 swig_obj[0] = args;
48212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48213 if (!SWIG_IsOK(res1)) {
48214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48215 }
48216 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48217 {
48218 PyThreadState* __tstate = wxPyBeginAllowThreads();
48219 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48220 wxPyEndAllowThreads(__tstate);
48221 if (PyErr_Occurred()) SWIG_fail;
48222 }
48223 {
48224 resultobj = wxPyMake_wxObject(result, (bool)0);
48225 }
48226 return resultobj;
48227 fail:
48228 return NULL;
48229 }
48230
48231
48232 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48233 PyObject *resultobj = 0;
48234 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48235 wxButton *result = 0 ;
48236 void *argp1 = 0 ;
48237 int res1 = 0 ;
48238 PyObject *swig_obj[1] ;
48239
48240 if (!args) SWIG_fail;
48241 swig_obj[0] = args;
48242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48243 if (!SWIG_IsOK(res1)) {
48244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48245 }
48246 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48247 {
48248 PyThreadState* __tstate = wxPyBeginAllowThreads();
48249 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48250 wxPyEndAllowThreads(__tstate);
48251 if (PyErr_Occurred()) SWIG_fail;
48252 }
48253 {
48254 resultobj = wxPyMake_wxObject(result, (bool)0);
48255 }
48256 return resultobj;
48257 fail:
48258 return NULL;
48259 }
48260
48261
48262 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48263 PyObject *resultobj = 0;
48264 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48265 wxButton *result = 0 ;
48266 void *argp1 = 0 ;
48267 int res1 = 0 ;
48268 PyObject *swig_obj[1] ;
48269
48270 if (!args) SWIG_fail;
48271 swig_obj[0] = args;
48272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48275 }
48276 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48277 {
48278 PyThreadState* __tstate = wxPyBeginAllowThreads();
48279 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48280 wxPyEndAllowThreads(__tstate);
48281 if (PyErr_Occurred()) SWIG_fail;
48282 }
48283 {
48284 resultobj = wxPyMake_wxObject(result, (bool)0);
48285 }
48286 return resultobj;
48287 fail:
48288 return NULL;
48289 }
48290
48291
48292 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48293 PyObject *resultobj = 0;
48294 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48295 wxButton *result = 0 ;
48296 void *argp1 = 0 ;
48297 int res1 = 0 ;
48298 PyObject *swig_obj[1] ;
48299
48300 if (!args) SWIG_fail;
48301 swig_obj[0] = args;
48302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48303 if (!SWIG_IsOK(res1)) {
48304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48305 }
48306 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48307 {
48308 PyThreadState* __tstate = wxPyBeginAllowThreads();
48309 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48310 wxPyEndAllowThreads(__tstate);
48311 if (PyErr_Occurred()) SWIG_fail;
48312 }
48313 {
48314 resultobj = wxPyMake_wxObject(result, (bool)0);
48315 }
48316 return resultobj;
48317 fail:
48318 return NULL;
48319 }
48320
48321
48322 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48323 PyObject *obj;
48324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48325 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48326 return SWIG_Py_Void();
48327 }
48328
48329 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48330 return SWIG_Python_InitShadowInstance(args);
48331 }
48332
48333 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48334 PyObject *resultobj = 0;
48335 int arg1 = (int) 0 ;
48336 int arg2 = (int) 0 ;
48337 wxGBPosition *result = 0 ;
48338 int val1 ;
48339 int ecode1 = 0 ;
48340 int val2 ;
48341 int ecode2 = 0 ;
48342 PyObject * obj0 = 0 ;
48343 PyObject * obj1 = 0 ;
48344 char * kwnames[] = {
48345 (char *) "row",(char *) "col", NULL
48346 };
48347
48348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48349 if (obj0) {
48350 ecode1 = SWIG_AsVal_int(obj0, &val1);
48351 if (!SWIG_IsOK(ecode1)) {
48352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48353 }
48354 arg1 = static_cast< int >(val1);
48355 }
48356 if (obj1) {
48357 ecode2 = SWIG_AsVal_int(obj1, &val2);
48358 if (!SWIG_IsOK(ecode2)) {
48359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48360 }
48361 arg2 = static_cast< int >(val2);
48362 }
48363 {
48364 PyThreadState* __tstate = wxPyBeginAllowThreads();
48365 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48366 wxPyEndAllowThreads(__tstate);
48367 if (PyErr_Occurred()) SWIG_fail;
48368 }
48369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48370 return resultobj;
48371 fail:
48372 return NULL;
48373 }
48374
48375
48376 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48377 PyObject *resultobj = 0;
48378 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48379 void *argp1 = 0 ;
48380 int res1 = 0 ;
48381 PyObject *swig_obj[1] ;
48382
48383 if (!args) SWIG_fail;
48384 swig_obj[0] = args;
48385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48386 if (!SWIG_IsOK(res1)) {
48387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48388 }
48389 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48390 {
48391 PyThreadState* __tstate = wxPyBeginAllowThreads();
48392 delete arg1;
48393
48394 wxPyEndAllowThreads(__tstate);
48395 if (PyErr_Occurred()) SWIG_fail;
48396 }
48397 resultobj = SWIG_Py_Void();
48398 return resultobj;
48399 fail:
48400 return NULL;
48401 }
48402
48403
48404 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48405 PyObject *resultobj = 0;
48406 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48407 int result;
48408 void *argp1 = 0 ;
48409 int res1 = 0 ;
48410 PyObject *swig_obj[1] ;
48411
48412 if (!args) SWIG_fail;
48413 swig_obj[0] = args;
48414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48415 if (!SWIG_IsOK(res1)) {
48416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48417 }
48418 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48419 {
48420 PyThreadState* __tstate = wxPyBeginAllowThreads();
48421 result = (int)((wxGBPosition const *)arg1)->GetRow();
48422 wxPyEndAllowThreads(__tstate);
48423 if (PyErr_Occurred()) SWIG_fail;
48424 }
48425 resultobj = SWIG_From_int(static_cast< int >(result));
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48433 PyObject *resultobj = 0;
48434 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48435 int result;
48436 void *argp1 = 0 ;
48437 int res1 = 0 ;
48438 PyObject *swig_obj[1] ;
48439
48440 if (!args) SWIG_fail;
48441 swig_obj[0] = args;
48442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48443 if (!SWIG_IsOK(res1)) {
48444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48445 }
48446 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48447 {
48448 PyThreadState* __tstate = wxPyBeginAllowThreads();
48449 result = (int)((wxGBPosition const *)arg1)->GetCol();
48450 wxPyEndAllowThreads(__tstate);
48451 if (PyErr_Occurred()) SWIG_fail;
48452 }
48453 resultobj = SWIG_From_int(static_cast< int >(result));
48454 return resultobj;
48455 fail:
48456 return NULL;
48457 }
48458
48459
48460 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48461 PyObject *resultobj = 0;
48462 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48463 int arg2 ;
48464 void *argp1 = 0 ;
48465 int res1 = 0 ;
48466 int val2 ;
48467 int ecode2 = 0 ;
48468 PyObject * obj0 = 0 ;
48469 PyObject * obj1 = 0 ;
48470 char * kwnames[] = {
48471 (char *) "self",(char *) "row", NULL
48472 };
48473
48474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48476 if (!SWIG_IsOK(res1)) {
48477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48478 }
48479 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48480 ecode2 = SWIG_AsVal_int(obj1, &val2);
48481 if (!SWIG_IsOK(ecode2)) {
48482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48483 }
48484 arg2 = static_cast< int >(val2);
48485 {
48486 PyThreadState* __tstate = wxPyBeginAllowThreads();
48487 (arg1)->SetRow(arg2);
48488 wxPyEndAllowThreads(__tstate);
48489 if (PyErr_Occurred()) SWIG_fail;
48490 }
48491 resultobj = SWIG_Py_Void();
48492 return resultobj;
48493 fail:
48494 return NULL;
48495 }
48496
48497
48498 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48499 PyObject *resultobj = 0;
48500 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48501 int arg2 ;
48502 void *argp1 = 0 ;
48503 int res1 = 0 ;
48504 int val2 ;
48505 int ecode2 = 0 ;
48506 PyObject * obj0 = 0 ;
48507 PyObject * obj1 = 0 ;
48508 char * kwnames[] = {
48509 (char *) "self",(char *) "col", NULL
48510 };
48511
48512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48514 if (!SWIG_IsOK(res1)) {
48515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48516 }
48517 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48518 ecode2 = SWIG_AsVal_int(obj1, &val2);
48519 if (!SWIG_IsOK(ecode2)) {
48520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48521 }
48522 arg2 = static_cast< int >(val2);
48523 {
48524 PyThreadState* __tstate = wxPyBeginAllowThreads();
48525 (arg1)->SetCol(arg2);
48526 wxPyEndAllowThreads(__tstate);
48527 if (PyErr_Occurred()) SWIG_fail;
48528 }
48529 resultobj = SWIG_Py_Void();
48530 return resultobj;
48531 fail:
48532 return NULL;
48533 }
48534
48535
48536 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48537 PyObject *resultobj = 0;
48538 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48539 wxGBPosition *arg2 = 0 ;
48540 bool result;
48541 void *argp1 = 0 ;
48542 int res1 = 0 ;
48543 wxGBPosition temp2 ;
48544 PyObject * obj0 = 0 ;
48545 PyObject * obj1 = 0 ;
48546 char * kwnames[] = {
48547 (char *) "self",(char *) "other", NULL
48548 };
48549
48550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48552 if (!SWIG_IsOK(res1)) {
48553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48554 }
48555 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48556 {
48557 arg2 = &temp2;
48558 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48559 }
48560 {
48561 PyThreadState* __tstate = wxPyBeginAllowThreads();
48562 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48563 wxPyEndAllowThreads(__tstate);
48564 if (PyErr_Occurred()) SWIG_fail;
48565 }
48566 {
48567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48568 }
48569 return resultobj;
48570 fail:
48571 return NULL;
48572 }
48573
48574
48575 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48576 PyObject *resultobj = 0;
48577 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48578 wxGBPosition *arg2 = 0 ;
48579 bool result;
48580 void *argp1 = 0 ;
48581 int res1 = 0 ;
48582 wxGBPosition temp2 ;
48583 PyObject * obj0 = 0 ;
48584 PyObject * obj1 = 0 ;
48585 char * kwnames[] = {
48586 (char *) "self",(char *) "other", NULL
48587 };
48588
48589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48591 if (!SWIG_IsOK(res1)) {
48592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48593 }
48594 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48595 {
48596 arg2 = &temp2;
48597 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48598 }
48599 {
48600 PyThreadState* __tstate = wxPyBeginAllowThreads();
48601 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48602 wxPyEndAllowThreads(__tstate);
48603 if (PyErr_Occurred()) SWIG_fail;
48604 }
48605 {
48606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48607 }
48608 return resultobj;
48609 fail:
48610 return NULL;
48611 }
48612
48613
48614 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48615 PyObject *resultobj = 0;
48616 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48617 int arg2 = (int) 0 ;
48618 int arg3 = (int) 0 ;
48619 void *argp1 = 0 ;
48620 int res1 = 0 ;
48621 int val2 ;
48622 int ecode2 = 0 ;
48623 int val3 ;
48624 int ecode3 = 0 ;
48625 PyObject * obj0 = 0 ;
48626 PyObject * obj1 = 0 ;
48627 PyObject * obj2 = 0 ;
48628 char * kwnames[] = {
48629 (char *) "self",(char *) "row",(char *) "col", NULL
48630 };
48631
48632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48634 if (!SWIG_IsOK(res1)) {
48635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48636 }
48637 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48638 if (obj1) {
48639 ecode2 = SWIG_AsVal_int(obj1, &val2);
48640 if (!SWIG_IsOK(ecode2)) {
48641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48642 }
48643 arg2 = static_cast< int >(val2);
48644 }
48645 if (obj2) {
48646 ecode3 = SWIG_AsVal_int(obj2, &val3);
48647 if (!SWIG_IsOK(ecode3)) {
48648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48649 }
48650 arg3 = static_cast< int >(val3);
48651 }
48652 {
48653 PyThreadState* __tstate = wxPyBeginAllowThreads();
48654 wxGBPosition_Set(arg1,arg2,arg3);
48655 wxPyEndAllowThreads(__tstate);
48656 if (PyErr_Occurred()) SWIG_fail;
48657 }
48658 resultobj = SWIG_Py_Void();
48659 return resultobj;
48660 fail:
48661 return NULL;
48662 }
48663
48664
48665 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48666 PyObject *resultobj = 0;
48667 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48668 PyObject *result = 0 ;
48669 void *argp1 = 0 ;
48670 int res1 = 0 ;
48671 PyObject *swig_obj[1] ;
48672
48673 if (!args) SWIG_fail;
48674 swig_obj[0] = args;
48675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48676 if (!SWIG_IsOK(res1)) {
48677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48678 }
48679 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48680 {
48681 PyThreadState* __tstate = wxPyBeginAllowThreads();
48682 result = (PyObject *)wxGBPosition_Get(arg1);
48683 wxPyEndAllowThreads(__tstate);
48684 if (PyErr_Occurred()) SWIG_fail;
48685 }
48686 resultobj = result;
48687 return resultobj;
48688 fail:
48689 return NULL;
48690 }
48691
48692
48693 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48694 PyObject *obj;
48695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48696 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48697 return SWIG_Py_Void();
48698 }
48699
48700 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48701 return SWIG_Python_InitShadowInstance(args);
48702 }
48703
48704 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48705 PyObject *resultobj = 0;
48706 int arg1 = (int) 1 ;
48707 int arg2 = (int) 1 ;
48708 wxGBSpan *result = 0 ;
48709 int val1 ;
48710 int ecode1 = 0 ;
48711 int val2 ;
48712 int ecode2 = 0 ;
48713 PyObject * obj0 = 0 ;
48714 PyObject * obj1 = 0 ;
48715 char * kwnames[] = {
48716 (char *) "rowspan",(char *) "colspan", NULL
48717 };
48718
48719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48720 if (obj0) {
48721 ecode1 = SWIG_AsVal_int(obj0, &val1);
48722 if (!SWIG_IsOK(ecode1)) {
48723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48724 }
48725 arg1 = static_cast< int >(val1);
48726 }
48727 if (obj1) {
48728 ecode2 = SWIG_AsVal_int(obj1, &val2);
48729 if (!SWIG_IsOK(ecode2)) {
48730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48731 }
48732 arg2 = static_cast< int >(val2);
48733 }
48734 {
48735 PyThreadState* __tstate = wxPyBeginAllowThreads();
48736 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48737 wxPyEndAllowThreads(__tstate);
48738 if (PyErr_Occurred()) SWIG_fail;
48739 }
48740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48741 return resultobj;
48742 fail:
48743 return NULL;
48744 }
48745
48746
48747 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48748 PyObject *resultobj = 0;
48749 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48750 void *argp1 = 0 ;
48751 int res1 = 0 ;
48752 PyObject *swig_obj[1] ;
48753
48754 if (!args) SWIG_fail;
48755 swig_obj[0] = args;
48756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48757 if (!SWIG_IsOK(res1)) {
48758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48759 }
48760 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48761 {
48762 PyThreadState* __tstate = wxPyBeginAllowThreads();
48763 delete arg1;
48764
48765 wxPyEndAllowThreads(__tstate);
48766 if (PyErr_Occurred()) SWIG_fail;
48767 }
48768 resultobj = SWIG_Py_Void();
48769 return resultobj;
48770 fail:
48771 return NULL;
48772 }
48773
48774
48775 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48776 PyObject *resultobj = 0;
48777 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48778 int result;
48779 void *argp1 = 0 ;
48780 int res1 = 0 ;
48781 PyObject *swig_obj[1] ;
48782
48783 if (!args) SWIG_fail;
48784 swig_obj[0] = args;
48785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48786 if (!SWIG_IsOK(res1)) {
48787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48788 }
48789 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48790 {
48791 PyThreadState* __tstate = wxPyBeginAllowThreads();
48792 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48793 wxPyEndAllowThreads(__tstate);
48794 if (PyErr_Occurred()) SWIG_fail;
48795 }
48796 resultobj = SWIG_From_int(static_cast< int >(result));
48797 return resultobj;
48798 fail:
48799 return NULL;
48800 }
48801
48802
48803 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48804 PyObject *resultobj = 0;
48805 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48806 int result;
48807 void *argp1 = 0 ;
48808 int res1 = 0 ;
48809 PyObject *swig_obj[1] ;
48810
48811 if (!args) SWIG_fail;
48812 swig_obj[0] = args;
48813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48814 if (!SWIG_IsOK(res1)) {
48815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48816 }
48817 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48818 {
48819 PyThreadState* __tstate = wxPyBeginAllowThreads();
48820 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48821 wxPyEndAllowThreads(__tstate);
48822 if (PyErr_Occurred()) SWIG_fail;
48823 }
48824 resultobj = SWIG_From_int(static_cast< int >(result));
48825 return resultobj;
48826 fail:
48827 return NULL;
48828 }
48829
48830
48831 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48832 PyObject *resultobj = 0;
48833 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48834 int arg2 ;
48835 void *argp1 = 0 ;
48836 int res1 = 0 ;
48837 int val2 ;
48838 int ecode2 = 0 ;
48839 PyObject * obj0 = 0 ;
48840 PyObject * obj1 = 0 ;
48841 char * kwnames[] = {
48842 (char *) "self",(char *) "rowspan", NULL
48843 };
48844
48845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48847 if (!SWIG_IsOK(res1)) {
48848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48849 }
48850 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48851 ecode2 = SWIG_AsVal_int(obj1, &val2);
48852 if (!SWIG_IsOK(ecode2)) {
48853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48854 }
48855 arg2 = static_cast< int >(val2);
48856 {
48857 PyThreadState* __tstate = wxPyBeginAllowThreads();
48858 (arg1)->SetRowspan(arg2);
48859 wxPyEndAllowThreads(__tstate);
48860 if (PyErr_Occurred()) SWIG_fail;
48861 }
48862 resultobj = SWIG_Py_Void();
48863 return resultobj;
48864 fail:
48865 return NULL;
48866 }
48867
48868
48869 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48870 PyObject *resultobj = 0;
48871 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48872 int arg2 ;
48873 void *argp1 = 0 ;
48874 int res1 = 0 ;
48875 int val2 ;
48876 int ecode2 = 0 ;
48877 PyObject * obj0 = 0 ;
48878 PyObject * obj1 = 0 ;
48879 char * kwnames[] = {
48880 (char *) "self",(char *) "colspan", NULL
48881 };
48882
48883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
48884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48885 if (!SWIG_IsOK(res1)) {
48886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48887 }
48888 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48889 ecode2 = SWIG_AsVal_int(obj1, &val2);
48890 if (!SWIG_IsOK(ecode2)) {
48891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
48892 }
48893 arg2 = static_cast< int >(val2);
48894 {
48895 PyThreadState* __tstate = wxPyBeginAllowThreads();
48896 (arg1)->SetColspan(arg2);
48897 wxPyEndAllowThreads(__tstate);
48898 if (PyErr_Occurred()) SWIG_fail;
48899 }
48900 resultobj = SWIG_Py_Void();
48901 return resultobj;
48902 fail:
48903 return NULL;
48904 }
48905
48906
48907 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48908 PyObject *resultobj = 0;
48909 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48910 wxGBSpan *arg2 = 0 ;
48911 bool result;
48912 void *argp1 = 0 ;
48913 int res1 = 0 ;
48914 wxGBSpan temp2 ;
48915 PyObject * obj0 = 0 ;
48916 PyObject * obj1 = 0 ;
48917 char * kwnames[] = {
48918 (char *) "self",(char *) "other", NULL
48919 };
48920
48921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48923 if (!SWIG_IsOK(res1)) {
48924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48925 }
48926 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48927 {
48928 arg2 = &temp2;
48929 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
48930 }
48931 {
48932 PyThreadState* __tstate = wxPyBeginAllowThreads();
48933 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
48934 wxPyEndAllowThreads(__tstate);
48935 if (PyErr_Occurred()) SWIG_fail;
48936 }
48937 {
48938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48939 }
48940 return resultobj;
48941 fail:
48942 return NULL;
48943 }
48944
48945
48946 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48947 PyObject *resultobj = 0;
48948 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48949 wxGBSpan *arg2 = 0 ;
48950 bool result;
48951 void *argp1 = 0 ;
48952 int res1 = 0 ;
48953 wxGBSpan temp2 ;
48954 PyObject * obj0 = 0 ;
48955 PyObject * obj1 = 0 ;
48956 char * kwnames[] = {
48957 (char *) "self",(char *) "other", NULL
48958 };
48959
48960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48962 if (!SWIG_IsOK(res1)) {
48963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48964 }
48965 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48966 {
48967 arg2 = &temp2;
48968 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
48969 }
48970 {
48971 PyThreadState* __tstate = wxPyBeginAllowThreads();
48972 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
48973 wxPyEndAllowThreads(__tstate);
48974 if (PyErr_Occurred()) SWIG_fail;
48975 }
48976 {
48977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48978 }
48979 return resultobj;
48980 fail:
48981 return NULL;
48982 }
48983
48984
48985 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48986 PyObject *resultobj = 0;
48987 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48988 int arg2 = (int) 1 ;
48989 int arg3 = (int) 1 ;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 int val2 ;
48993 int ecode2 = 0 ;
48994 int val3 ;
48995 int ecode3 = 0 ;
48996 PyObject * obj0 = 0 ;
48997 PyObject * obj1 = 0 ;
48998 PyObject * obj2 = 0 ;
48999 char * kwnames[] = {
49000 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49001 };
49002
49003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49005 if (!SWIG_IsOK(res1)) {
49006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49007 }
49008 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49009 if (obj1) {
49010 ecode2 = SWIG_AsVal_int(obj1, &val2);
49011 if (!SWIG_IsOK(ecode2)) {
49012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49013 }
49014 arg2 = static_cast< int >(val2);
49015 }
49016 if (obj2) {
49017 ecode3 = SWIG_AsVal_int(obj2, &val3);
49018 if (!SWIG_IsOK(ecode3)) {
49019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49020 }
49021 arg3 = static_cast< int >(val3);
49022 }
49023 {
49024 PyThreadState* __tstate = wxPyBeginAllowThreads();
49025 wxGBSpan_Set(arg1,arg2,arg3);
49026 wxPyEndAllowThreads(__tstate);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 resultobj = SWIG_Py_Void();
49030 return resultobj;
49031 fail:
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49037 PyObject *resultobj = 0;
49038 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49039 PyObject *result = 0 ;
49040 void *argp1 = 0 ;
49041 int res1 = 0 ;
49042 PyObject *swig_obj[1] ;
49043
49044 if (!args) SWIG_fail;
49045 swig_obj[0] = args;
49046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49047 if (!SWIG_IsOK(res1)) {
49048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49049 }
49050 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49051 {
49052 PyThreadState* __tstate = wxPyBeginAllowThreads();
49053 result = (PyObject *)wxGBSpan_Get(arg1);
49054 wxPyEndAllowThreads(__tstate);
49055 if (PyErr_Occurred()) SWIG_fail;
49056 }
49057 resultobj = result;
49058 return resultobj;
49059 fail:
49060 return NULL;
49061 }
49062
49063
49064 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49065 PyObject *obj;
49066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49067 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49068 return SWIG_Py_Void();
49069 }
49070
49071 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49072 return SWIG_Python_InitShadowInstance(args);
49073 }
49074
49075 SWIGINTERN int DefaultSpan_set(PyObject *) {
49076 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49077 return 1;
49078 }
49079
49080
49081 SWIGINTERN PyObject *DefaultSpan_get(void) {
49082 PyObject *pyobj = 0;
49083
49084 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49085 return pyobj;
49086 }
49087
49088
49089 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49090 PyObject *resultobj = 0;
49091 wxGBSizerItem *result = 0 ;
49092
49093 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49094 {
49095 PyThreadState* __tstate = wxPyBeginAllowThreads();
49096 result = (wxGBSizerItem *)new wxGBSizerItem();
49097 wxPyEndAllowThreads(__tstate);
49098 if (PyErr_Occurred()) SWIG_fail;
49099 }
49100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49101 return resultobj;
49102 fail:
49103 return NULL;
49104 }
49105
49106
49107 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49108 PyObject *resultobj = 0;
49109 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49110 void *argp1 = 0 ;
49111 int res1 = 0 ;
49112 PyObject *swig_obj[1] ;
49113
49114 if (!args) SWIG_fail;
49115 swig_obj[0] = args;
49116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49117 if (!SWIG_IsOK(res1)) {
49118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49119 }
49120 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49121 {
49122 PyThreadState* __tstate = wxPyBeginAllowThreads();
49123 delete arg1;
49124
49125 wxPyEndAllowThreads(__tstate);
49126 if (PyErr_Occurred()) SWIG_fail;
49127 }
49128 resultobj = SWIG_Py_Void();
49129 return resultobj;
49130 fail:
49131 return NULL;
49132 }
49133
49134
49135 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49136 PyObject *resultobj = 0;
49137 wxWindow *arg1 = (wxWindow *) 0 ;
49138 wxGBPosition *arg2 = 0 ;
49139 wxGBSpan *arg3 = 0 ;
49140 int arg4 ;
49141 int arg5 ;
49142 PyObject *arg6 = (PyObject *) NULL ;
49143 wxGBSizerItem *result = 0 ;
49144 void *argp1 = 0 ;
49145 int res1 = 0 ;
49146 wxGBPosition temp2 ;
49147 wxGBSpan temp3 ;
49148 int val4 ;
49149 int ecode4 = 0 ;
49150 int val5 ;
49151 int ecode5 = 0 ;
49152 PyObject * obj0 = 0 ;
49153 PyObject * obj1 = 0 ;
49154 PyObject * obj2 = 0 ;
49155 PyObject * obj3 = 0 ;
49156 PyObject * obj4 = 0 ;
49157 PyObject * obj5 = 0 ;
49158 char * kwnames[] = {
49159 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49160 };
49161
49162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49164 if (!SWIG_IsOK(res1)) {
49165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49166 }
49167 arg1 = reinterpret_cast< wxWindow * >(argp1);
49168 {
49169 arg2 = &temp2;
49170 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49171 }
49172 {
49173 arg3 = &temp3;
49174 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49175 }
49176 ecode4 = SWIG_AsVal_int(obj3, &val4);
49177 if (!SWIG_IsOK(ecode4)) {
49178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49179 }
49180 arg4 = static_cast< int >(val4);
49181 ecode5 = SWIG_AsVal_int(obj4, &val5);
49182 if (!SWIG_IsOK(ecode5)) {
49183 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49184 }
49185 arg5 = static_cast< int >(val5);
49186 if (obj5) {
49187 arg6 = obj5;
49188 }
49189 {
49190 PyThreadState* __tstate = wxPyBeginAllowThreads();
49191 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49192 wxPyEndAllowThreads(__tstate);
49193 if (PyErr_Occurred()) SWIG_fail;
49194 }
49195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49196 return resultobj;
49197 fail:
49198 return NULL;
49199 }
49200
49201
49202 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49203 PyObject *resultobj = 0;
49204 wxSizer *arg1 = (wxSizer *) 0 ;
49205 wxGBPosition *arg2 = 0 ;
49206 wxGBSpan *arg3 = 0 ;
49207 int arg4 ;
49208 int arg5 ;
49209 PyObject *arg6 = (PyObject *) NULL ;
49210 wxGBSizerItem *result = 0 ;
49211 int res1 = 0 ;
49212 wxGBPosition temp2 ;
49213 wxGBSpan temp3 ;
49214 int val4 ;
49215 int ecode4 = 0 ;
49216 int val5 ;
49217 int ecode5 = 0 ;
49218 PyObject * obj0 = 0 ;
49219 PyObject * obj1 = 0 ;
49220 PyObject * obj2 = 0 ;
49221 PyObject * obj3 = 0 ;
49222 PyObject * obj4 = 0 ;
49223 PyObject * obj5 = 0 ;
49224 char * kwnames[] = {
49225 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49226 };
49227
49228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49229 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49230 if (!SWIG_IsOK(res1)) {
49231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49232 }
49233 {
49234 arg2 = &temp2;
49235 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49236 }
49237 {
49238 arg3 = &temp3;
49239 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49240 }
49241 ecode4 = SWIG_AsVal_int(obj3, &val4);
49242 if (!SWIG_IsOK(ecode4)) {
49243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49244 }
49245 arg4 = static_cast< int >(val4);
49246 ecode5 = SWIG_AsVal_int(obj4, &val5);
49247 if (!SWIG_IsOK(ecode5)) {
49248 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49249 }
49250 arg5 = static_cast< int >(val5);
49251 if (obj5) {
49252 arg6 = obj5;
49253 }
49254 {
49255 PyThreadState* __tstate = wxPyBeginAllowThreads();
49256 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49257 wxPyEndAllowThreads(__tstate);
49258 if (PyErr_Occurred()) SWIG_fail;
49259 }
49260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49261 return resultobj;
49262 fail:
49263 return NULL;
49264 }
49265
49266
49267 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49268 PyObject *resultobj = 0;
49269 int arg1 ;
49270 int arg2 ;
49271 wxGBPosition *arg3 = 0 ;
49272 wxGBSpan *arg4 = 0 ;
49273 int arg5 ;
49274 int arg6 ;
49275 PyObject *arg7 = (PyObject *) NULL ;
49276 wxGBSizerItem *result = 0 ;
49277 int val1 ;
49278 int ecode1 = 0 ;
49279 int val2 ;
49280 int ecode2 = 0 ;
49281 wxGBPosition temp3 ;
49282 wxGBSpan temp4 ;
49283 int val5 ;
49284 int ecode5 = 0 ;
49285 int val6 ;
49286 int ecode6 = 0 ;
49287 PyObject * obj0 = 0 ;
49288 PyObject * obj1 = 0 ;
49289 PyObject * obj2 = 0 ;
49290 PyObject * obj3 = 0 ;
49291 PyObject * obj4 = 0 ;
49292 PyObject * obj5 = 0 ;
49293 PyObject * obj6 = 0 ;
49294 char * kwnames[] = {
49295 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49296 };
49297
49298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49299 ecode1 = SWIG_AsVal_int(obj0, &val1);
49300 if (!SWIG_IsOK(ecode1)) {
49301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49302 }
49303 arg1 = static_cast< int >(val1);
49304 ecode2 = SWIG_AsVal_int(obj1, &val2);
49305 if (!SWIG_IsOK(ecode2)) {
49306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49307 }
49308 arg2 = static_cast< int >(val2);
49309 {
49310 arg3 = &temp3;
49311 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49312 }
49313 {
49314 arg4 = &temp4;
49315 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49316 }
49317 ecode5 = SWIG_AsVal_int(obj4, &val5);
49318 if (!SWIG_IsOK(ecode5)) {
49319 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49320 }
49321 arg5 = static_cast< int >(val5);
49322 ecode6 = SWIG_AsVal_int(obj5, &val6);
49323 if (!SWIG_IsOK(ecode6)) {
49324 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49325 }
49326 arg6 = static_cast< int >(val6);
49327 if (obj6) {
49328 arg7 = obj6;
49329 }
49330 {
49331 PyThreadState* __tstate = wxPyBeginAllowThreads();
49332 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49333 wxPyEndAllowThreads(__tstate);
49334 if (PyErr_Occurred()) SWIG_fail;
49335 }
49336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49337 return resultobj;
49338 fail:
49339 return NULL;
49340 }
49341
49342
49343 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49344 PyObject *resultobj = 0;
49345 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49346 wxGBPosition result;
49347 void *argp1 = 0 ;
49348 int res1 = 0 ;
49349 PyObject *swig_obj[1] ;
49350
49351 if (!args) SWIG_fail;
49352 swig_obj[0] = args;
49353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49354 if (!SWIG_IsOK(res1)) {
49355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49356 }
49357 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49358 {
49359 PyThreadState* __tstate = wxPyBeginAllowThreads();
49360 result = ((wxGBSizerItem const *)arg1)->GetPos();
49361 wxPyEndAllowThreads(__tstate);
49362 if (PyErr_Occurred()) SWIG_fail;
49363 }
49364 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49365 return resultobj;
49366 fail:
49367 return NULL;
49368 }
49369
49370
49371 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49372 PyObject *resultobj = 0;
49373 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49374 wxGBSpan result;
49375 void *argp1 = 0 ;
49376 int res1 = 0 ;
49377 PyObject *swig_obj[1] ;
49378
49379 if (!args) SWIG_fail;
49380 swig_obj[0] = args;
49381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49382 if (!SWIG_IsOK(res1)) {
49383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49384 }
49385 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49386 {
49387 PyThreadState* __tstate = wxPyBeginAllowThreads();
49388 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49389 wxPyEndAllowThreads(__tstate);
49390 if (PyErr_Occurred()) SWIG_fail;
49391 }
49392 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49393 return resultobj;
49394 fail:
49395 return NULL;
49396 }
49397
49398
49399 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49400 PyObject *resultobj = 0;
49401 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49402 wxGBPosition *arg2 = 0 ;
49403 bool result;
49404 void *argp1 = 0 ;
49405 int res1 = 0 ;
49406 wxGBPosition temp2 ;
49407 PyObject * obj0 = 0 ;
49408 PyObject * obj1 = 0 ;
49409 char * kwnames[] = {
49410 (char *) "self",(char *) "pos", NULL
49411 };
49412
49413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49415 if (!SWIG_IsOK(res1)) {
49416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49417 }
49418 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49419 {
49420 arg2 = &temp2;
49421 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49422 }
49423 {
49424 PyThreadState* __tstate = wxPyBeginAllowThreads();
49425 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49426 wxPyEndAllowThreads(__tstate);
49427 if (PyErr_Occurred()) SWIG_fail;
49428 }
49429 {
49430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49431 }
49432 return resultobj;
49433 fail:
49434 return NULL;
49435 }
49436
49437
49438 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49439 PyObject *resultobj = 0;
49440 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49441 wxGBSpan *arg2 = 0 ;
49442 bool result;
49443 void *argp1 = 0 ;
49444 int res1 = 0 ;
49445 wxGBSpan temp2 ;
49446 PyObject * obj0 = 0 ;
49447 PyObject * obj1 = 0 ;
49448 char * kwnames[] = {
49449 (char *) "self",(char *) "span", NULL
49450 };
49451
49452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49454 if (!SWIG_IsOK(res1)) {
49455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49456 }
49457 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49458 {
49459 arg2 = &temp2;
49460 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49461 }
49462 {
49463 PyThreadState* __tstate = wxPyBeginAllowThreads();
49464 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49465 wxPyEndAllowThreads(__tstate);
49466 if (PyErr_Occurred()) SWIG_fail;
49467 }
49468 {
49469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49470 }
49471 return resultobj;
49472 fail:
49473 return NULL;
49474 }
49475
49476
49477 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49478 PyObject *resultobj = 0;
49479 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49480 wxGBSizerItem *arg2 = 0 ;
49481 bool result;
49482 void *argp1 = 0 ;
49483 int res1 = 0 ;
49484 void *argp2 = 0 ;
49485 int res2 = 0 ;
49486 PyObject * obj0 = 0 ;
49487 PyObject * obj1 = 0 ;
49488 char * kwnames[] = {
49489 (char *) "self",(char *) "other", NULL
49490 };
49491
49492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49494 if (!SWIG_IsOK(res1)) {
49495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49496 }
49497 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49498 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49499 if (!SWIG_IsOK(res2)) {
49500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49501 }
49502 if (!argp2) {
49503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49504 }
49505 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49506 {
49507 PyThreadState* __tstate = wxPyBeginAllowThreads();
49508 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49509 wxPyEndAllowThreads(__tstate);
49510 if (PyErr_Occurred()) SWIG_fail;
49511 }
49512 {
49513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49514 }
49515 return resultobj;
49516 fail:
49517 return NULL;
49518 }
49519
49520
49521 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49522 PyObject *resultobj = 0;
49523 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49524 wxGBPosition *arg2 = 0 ;
49525 wxGBSpan *arg3 = 0 ;
49526 bool result;
49527 void *argp1 = 0 ;
49528 int res1 = 0 ;
49529 wxGBPosition temp2 ;
49530 wxGBSpan temp3 ;
49531 PyObject * obj0 = 0 ;
49532 PyObject * obj1 = 0 ;
49533 PyObject * obj2 = 0 ;
49534 char * kwnames[] = {
49535 (char *) "self",(char *) "pos",(char *) "span", NULL
49536 };
49537
49538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49540 if (!SWIG_IsOK(res1)) {
49541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49542 }
49543 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49544 {
49545 arg2 = &temp2;
49546 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49547 }
49548 {
49549 arg3 = &temp3;
49550 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49551 }
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 {
49559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49560 }
49561 return resultobj;
49562 fail:
49563 return NULL;
49564 }
49565
49566
49567 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49568 PyObject *resultobj = 0;
49569 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49570 wxGBPosition result;
49571 void *argp1 = 0 ;
49572 int res1 = 0 ;
49573 PyObject *swig_obj[1] ;
49574
49575 if (!args) SWIG_fail;
49576 swig_obj[0] = args;
49577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49578 if (!SWIG_IsOK(res1)) {
49579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49580 }
49581 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49582 {
49583 PyThreadState* __tstate = wxPyBeginAllowThreads();
49584 result = wxGBSizerItem_GetEndPos(arg1);
49585 wxPyEndAllowThreads(__tstate);
49586 if (PyErr_Occurred()) SWIG_fail;
49587 }
49588 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49589 return resultobj;
49590 fail:
49591 return NULL;
49592 }
49593
49594
49595 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49596 PyObject *resultobj = 0;
49597 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49598 wxGridBagSizer *result = 0 ;
49599 void *argp1 = 0 ;
49600 int res1 = 0 ;
49601 PyObject *swig_obj[1] ;
49602
49603 if (!args) SWIG_fail;
49604 swig_obj[0] = args;
49605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49606 if (!SWIG_IsOK(res1)) {
49607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49608 }
49609 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49610 {
49611 PyThreadState* __tstate = wxPyBeginAllowThreads();
49612 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49613 wxPyEndAllowThreads(__tstate);
49614 if (PyErr_Occurred()) SWIG_fail;
49615 }
49616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49617 return resultobj;
49618 fail:
49619 return NULL;
49620 }
49621
49622
49623 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49624 PyObject *resultobj = 0;
49625 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49626 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49627 void *argp1 = 0 ;
49628 int res1 = 0 ;
49629 void *argp2 = 0 ;
49630 int res2 = 0 ;
49631 PyObject * obj0 = 0 ;
49632 PyObject * obj1 = 0 ;
49633 char * kwnames[] = {
49634 (char *) "self",(char *) "sizer", NULL
49635 };
49636
49637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49639 if (!SWIG_IsOK(res1)) {
49640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49641 }
49642 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49644 if (!SWIG_IsOK(res2)) {
49645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49646 }
49647 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49648 {
49649 PyThreadState* __tstate = wxPyBeginAllowThreads();
49650 (arg1)->SetGBSizer(arg2);
49651 wxPyEndAllowThreads(__tstate);
49652 if (PyErr_Occurred()) SWIG_fail;
49653 }
49654 resultobj = SWIG_Py_Void();
49655 return resultobj;
49656 fail:
49657 return NULL;
49658 }
49659
49660
49661 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49662 PyObject *obj;
49663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49664 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49665 return SWIG_Py_Void();
49666 }
49667
49668 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49669 return SWIG_Python_InitShadowInstance(args);
49670 }
49671
49672 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49673 PyObject *resultobj = 0;
49674 int arg1 = (int) 0 ;
49675 int arg2 = (int) 0 ;
49676 wxGridBagSizer *result = 0 ;
49677 int val1 ;
49678 int ecode1 = 0 ;
49679 int val2 ;
49680 int ecode2 = 0 ;
49681 PyObject * obj0 = 0 ;
49682 PyObject * obj1 = 0 ;
49683 char * kwnames[] = {
49684 (char *) "vgap",(char *) "hgap", NULL
49685 };
49686
49687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49688 if (obj0) {
49689 ecode1 = SWIG_AsVal_int(obj0, &val1);
49690 if (!SWIG_IsOK(ecode1)) {
49691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49692 }
49693 arg1 = static_cast< int >(val1);
49694 }
49695 if (obj1) {
49696 ecode2 = SWIG_AsVal_int(obj1, &val2);
49697 if (!SWIG_IsOK(ecode2)) {
49698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49699 }
49700 arg2 = static_cast< int >(val2);
49701 }
49702 {
49703 PyThreadState* __tstate = wxPyBeginAllowThreads();
49704 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49705 wxPyEndAllowThreads(__tstate);
49706 if (PyErr_Occurred()) SWIG_fail;
49707 }
49708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49709 return resultobj;
49710 fail:
49711 return NULL;
49712 }
49713
49714
49715 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49716 PyObject *resultobj = 0;
49717 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49718 PyObject *arg2 = (PyObject *) 0 ;
49719 wxGBPosition *arg3 = 0 ;
49720 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49721 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49722 int arg5 = (int) 0 ;
49723 int arg6 = (int) 0 ;
49724 PyObject *arg7 = (PyObject *) NULL ;
49725 wxGBSizerItem *result = 0 ;
49726 void *argp1 = 0 ;
49727 int res1 = 0 ;
49728 wxGBPosition temp3 ;
49729 wxGBSpan temp4 ;
49730 int val5 ;
49731 int ecode5 = 0 ;
49732 int val6 ;
49733 int ecode6 = 0 ;
49734 PyObject * obj0 = 0 ;
49735 PyObject * obj1 = 0 ;
49736 PyObject * obj2 = 0 ;
49737 PyObject * obj3 = 0 ;
49738 PyObject * obj4 = 0 ;
49739 PyObject * obj5 = 0 ;
49740 PyObject * obj6 = 0 ;
49741 char * kwnames[] = {
49742 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49743 };
49744
49745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49747 if (!SWIG_IsOK(res1)) {
49748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49749 }
49750 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49751 arg2 = obj1;
49752 {
49753 arg3 = &temp3;
49754 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49755 }
49756 if (obj3) {
49757 {
49758 arg4 = &temp4;
49759 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49760 }
49761 }
49762 if (obj4) {
49763 ecode5 = SWIG_AsVal_int(obj4, &val5);
49764 if (!SWIG_IsOK(ecode5)) {
49765 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49766 }
49767 arg5 = static_cast< int >(val5);
49768 }
49769 if (obj5) {
49770 ecode6 = SWIG_AsVal_int(obj5, &val6);
49771 if (!SWIG_IsOK(ecode6)) {
49772 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49773 }
49774 arg6 = static_cast< int >(val6);
49775 }
49776 if (obj6) {
49777 arg7 = obj6;
49778 }
49779 {
49780 PyThreadState* __tstate = wxPyBeginAllowThreads();
49781 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49793 PyObject *resultobj = 0;
49794 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49795 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49796 wxGBSizerItem *result = 0 ;
49797 void *argp1 = 0 ;
49798 int res1 = 0 ;
49799 int res2 = 0 ;
49800 PyObject * obj0 = 0 ;
49801 PyObject * obj1 = 0 ;
49802 char * kwnames[] = {
49803 (char *) "self",(char *) "item", NULL
49804 };
49805
49806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49808 if (!SWIG_IsOK(res1)) {
49809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49810 }
49811 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49812 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49813 if (!SWIG_IsOK(res2)) {
49814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49815 }
49816 {
49817 PyThreadState* __tstate = wxPyBeginAllowThreads();
49818 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49819 wxPyEndAllowThreads(__tstate);
49820 if (PyErr_Occurred()) SWIG_fail;
49821 }
49822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49823 return resultobj;
49824 fail:
49825 return NULL;
49826 }
49827
49828
49829 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49830 PyObject *resultobj = 0;
49831 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49832 int arg2 ;
49833 int arg3 ;
49834 wxSize result;
49835 void *argp1 = 0 ;
49836 int res1 = 0 ;
49837 int val2 ;
49838 int ecode2 = 0 ;
49839 int val3 ;
49840 int ecode3 = 0 ;
49841 PyObject * obj0 = 0 ;
49842 PyObject * obj1 = 0 ;
49843 PyObject * obj2 = 0 ;
49844 char * kwnames[] = {
49845 (char *) "self",(char *) "row",(char *) "col", NULL
49846 };
49847
49848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49850 if (!SWIG_IsOK(res1)) {
49851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49852 }
49853 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49854 ecode2 = SWIG_AsVal_int(obj1, &val2);
49855 if (!SWIG_IsOK(ecode2)) {
49856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49857 }
49858 arg2 = static_cast< int >(val2);
49859 ecode3 = SWIG_AsVal_int(obj2, &val3);
49860 if (!SWIG_IsOK(ecode3)) {
49861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49862 }
49863 arg3 = static_cast< int >(val3);
49864 {
49865 PyThreadState* __tstate = wxPyBeginAllowThreads();
49866 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49867 wxPyEndAllowThreads(__tstate);
49868 if (PyErr_Occurred()) SWIG_fail;
49869 }
49870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49871 return resultobj;
49872 fail:
49873 return NULL;
49874 }
49875
49876
49877 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49878 PyObject *resultobj = 0;
49879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49880 wxSize result;
49881 void *argp1 = 0 ;
49882 int res1 = 0 ;
49883 PyObject *swig_obj[1] ;
49884
49885 if (!args) SWIG_fail;
49886 swig_obj[0] = args;
49887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49888 if (!SWIG_IsOK(res1)) {
49889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49890 }
49891 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49892 {
49893 PyThreadState* __tstate = wxPyBeginAllowThreads();
49894 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
49895 wxPyEndAllowThreads(__tstate);
49896 if (PyErr_Occurred()) SWIG_fail;
49897 }
49898 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49899 return resultobj;
49900 fail:
49901 return NULL;
49902 }
49903
49904
49905 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49906 PyObject *resultobj = 0;
49907 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49908 wxSize *arg2 = 0 ;
49909 void *argp1 = 0 ;
49910 int res1 = 0 ;
49911 wxSize temp2 ;
49912 PyObject * obj0 = 0 ;
49913 PyObject * obj1 = 0 ;
49914 char * kwnames[] = {
49915 (char *) "self",(char *) "sz", NULL
49916 };
49917
49918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
49919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49920 if (!SWIG_IsOK(res1)) {
49921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49922 }
49923 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49924 {
49925 arg2 = &temp2;
49926 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49927 }
49928 {
49929 PyThreadState* __tstate = wxPyBeginAllowThreads();
49930 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
49931 wxPyEndAllowThreads(__tstate);
49932 if (PyErr_Occurred()) SWIG_fail;
49933 }
49934 resultobj = SWIG_Py_Void();
49935 return resultobj;
49936 fail:
49937 return NULL;
49938 }
49939
49940
49941 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
49942 PyObject *resultobj = 0;
49943 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49944 wxWindow *arg2 = (wxWindow *) 0 ;
49945 wxGBPosition result;
49946 void *argp1 = 0 ;
49947 int res1 = 0 ;
49948 void *argp2 = 0 ;
49949 int res2 = 0 ;
49950
49951 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
49952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49953 if (!SWIG_IsOK(res1)) {
49954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49955 }
49956 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49957 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49958 if (!SWIG_IsOK(res2)) {
49959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
49960 }
49961 arg2 = reinterpret_cast< wxWindow * >(argp2);
49962 {
49963 PyThreadState* __tstate = wxPyBeginAllowThreads();
49964 result = (arg1)->GetItemPosition(arg2);
49965 wxPyEndAllowThreads(__tstate);
49966 if (PyErr_Occurred()) SWIG_fail;
49967 }
49968 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49969 return resultobj;
49970 fail:
49971 return NULL;
49972 }
49973
49974
49975 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
49976 PyObject *resultobj = 0;
49977 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49978 wxSizer *arg2 = (wxSizer *) 0 ;
49979 wxGBPosition result;
49980 void *argp1 = 0 ;
49981 int res1 = 0 ;
49982 void *argp2 = 0 ;
49983 int res2 = 0 ;
49984
49985 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
49986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49987 if (!SWIG_IsOK(res1)) {
49988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49989 }
49990 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49991 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
49992 if (!SWIG_IsOK(res2)) {
49993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
49994 }
49995 arg2 = reinterpret_cast< wxSizer * >(argp2);
49996 {
49997 PyThreadState* __tstate = wxPyBeginAllowThreads();
49998 result = (arg1)->GetItemPosition(arg2);
49999 wxPyEndAllowThreads(__tstate);
50000 if (PyErr_Occurred()) SWIG_fail;
50001 }
50002 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50003 return resultobj;
50004 fail:
50005 return NULL;
50006 }
50007
50008
50009 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50010 PyObject *resultobj = 0;
50011 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50012 size_t arg2 ;
50013 wxGBPosition result;
50014 void *argp1 = 0 ;
50015 int res1 = 0 ;
50016 size_t val2 ;
50017 int ecode2 = 0 ;
50018
50019 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50021 if (!SWIG_IsOK(res1)) {
50022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50023 }
50024 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50025 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50026 if (!SWIG_IsOK(ecode2)) {
50027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50028 }
50029 arg2 = static_cast< size_t >(val2);
50030 {
50031 PyThreadState* __tstate = wxPyBeginAllowThreads();
50032 result = (arg1)->GetItemPosition(arg2);
50033 wxPyEndAllowThreads(__tstate);
50034 if (PyErr_Occurred()) SWIG_fail;
50035 }
50036 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50037 return resultobj;
50038 fail:
50039 return NULL;
50040 }
50041
50042
50043 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50044 int argc;
50045 PyObject *argv[3];
50046
50047 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50048 --argc;
50049 if (argc == 2) {
50050 int _v = 0;
50051 {
50052 void *vptr = 0;
50053 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50054 _v = SWIG_CheckState(res);
50055 }
50056 if (!_v) goto check_1;
50057 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50058 }
50059 check_1:
50060
50061 if (argc == 2) {
50062 int _v = 0;
50063 {
50064 void *vptr = 0;
50065 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50066 _v = SWIG_CheckState(res);
50067 }
50068 if (!_v) goto check_2;
50069 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50070 }
50071 check_2:
50072
50073 if (argc == 2) {
50074 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50075 }
50076
50077 fail:
50078 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50084 PyObject *resultobj = 0;
50085 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50086 wxWindow *arg2 = (wxWindow *) 0 ;
50087 wxGBPosition *arg3 = 0 ;
50088 bool result;
50089 void *argp1 = 0 ;
50090 int res1 = 0 ;
50091 void *argp2 = 0 ;
50092 int res2 = 0 ;
50093 wxGBPosition temp3 ;
50094
50095 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50097 if (!SWIG_IsOK(res1)) {
50098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50099 }
50100 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50101 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50102 if (!SWIG_IsOK(res2)) {
50103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50104 }
50105 arg2 = reinterpret_cast< wxWindow * >(argp2);
50106 {
50107 arg3 = &temp3;
50108 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50109 }
50110 {
50111 PyThreadState* __tstate = wxPyBeginAllowThreads();
50112 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50113 wxPyEndAllowThreads(__tstate);
50114 if (PyErr_Occurred()) SWIG_fail;
50115 }
50116 {
50117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50118 }
50119 return resultobj;
50120 fail:
50121 return NULL;
50122 }
50123
50124
50125 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50126 PyObject *resultobj = 0;
50127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50128 wxSizer *arg2 = (wxSizer *) 0 ;
50129 wxGBPosition *arg3 = 0 ;
50130 bool result;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 void *argp2 = 0 ;
50134 int res2 = 0 ;
50135 wxGBPosition temp3 ;
50136
50137 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50139 if (!SWIG_IsOK(res1)) {
50140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50141 }
50142 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50143 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50144 if (!SWIG_IsOK(res2)) {
50145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50146 }
50147 arg2 = reinterpret_cast< wxSizer * >(argp2);
50148 {
50149 arg3 = &temp3;
50150 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50151 }
50152 {
50153 PyThreadState* __tstate = wxPyBeginAllowThreads();
50154 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50155 wxPyEndAllowThreads(__tstate);
50156 if (PyErr_Occurred()) SWIG_fail;
50157 }
50158 {
50159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50160 }
50161 return resultobj;
50162 fail:
50163 return NULL;
50164 }
50165
50166
50167 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50168 PyObject *resultobj = 0;
50169 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50170 size_t arg2 ;
50171 wxGBPosition *arg3 = 0 ;
50172 bool result;
50173 void *argp1 = 0 ;
50174 int res1 = 0 ;
50175 size_t val2 ;
50176 int ecode2 = 0 ;
50177 wxGBPosition temp3 ;
50178
50179 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50181 if (!SWIG_IsOK(res1)) {
50182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50183 }
50184 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50185 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50186 if (!SWIG_IsOK(ecode2)) {
50187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50188 }
50189 arg2 = static_cast< size_t >(val2);
50190 {
50191 arg3 = &temp3;
50192 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50193 }
50194 {
50195 PyThreadState* __tstate = wxPyBeginAllowThreads();
50196 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50197 wxPyEndAllowThreads(__tstate);
50198 if (PyErr_Occurred()) SWIG_fail;
50199 }
50200 {
50201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50202 }
50203 return resultobj;
50204 fail:
50205 return NULL;
50206 }
50207
50208
50209 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50210 int argc;
50211 PyObject *argv[4];
50212
50213 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50214 --argc;
50215 if (argc == 3) {
50216 int _v = 0;
50217 {
50218 void *vptr = 0;
50219 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50220 _v = SWIG_CheckState(res);
50221 }
50222 if (!_v) goto check_1;
50223 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50224 }
50225 check_1:
50226
50227 if (argc == 3) {
50228 int _v = 0;
50229 {
50230 void *vptr = 0;
50231 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50232 _v = SWIG_CheckState(res);
50233 }
50234 if (!_v) goto check_2;
50235 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50236 }
50237 check_2:
50238
50239 if (argc == 3) {
50240 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50241 }
50242
50243 fail:
50244 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50245 return NULL;
50246 }
50247
50248
50249 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50250 PyObject *resultobj = 0;
50251 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50252 wxWindow *arg2 = (wxWindow *) 0 ;
50253 wxGBSpan result;
50254 void *argp1 = 0 ;
50255 int res1 = 0 ;
50256 void *argp2 = 0 ;
50257 int res2 = 0 ;
50258
50259 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50261 if (!SWIG_IsOK(res1)) {
50262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50263 }
50264 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50265 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50266 if (!SWIG_IsOK(res2)) {
50267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50268 }
50269 arg2 = reinterpret_cast< wxWindow * >(argp2);
50270 {
50271 PyThreadState* __tstate = wxPyBeginAllowThreads();
50272 result = (arg1)->GetItemSpan(arg2);
50273 wxPyEndAllowThreads(__tstate);
50274 if (PyErr_Occurred()) SWIG_fail;
50275 }
50276 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50277 return resultobj;
50278 fail:
50279 return NULL;
50280 }
50281
50282
50283 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50284 PyObject *resultobj = 0;
50285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50286 wxSizer *arg2 = (wxSizer *) 0 ;
50287 wxGBSpan result;
50288 void *argp1 = 0 ;
50289 int res1 = 0 ;
50290 void *argp2 = 0 ;
50291 int res2 = 0 ;
50292
50293 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50295 if (!SWIG_IsOK(res1)) {
50296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50297 }
50298 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50299 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50300 if (!SWIG_IsOK(res2)) {
50301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50302 }
50303 arg2 = reinterpret_cast< wxSizer * >(argp2);
50304 {
50305 PyThreadState* __tstate = wxPyBeginAllowThreads();
50306 result = (arg1)->GetItemSpan(arg2);
50307 wxPyEndAllowThreads(__tstate);
50308 if (PyErr_Occurred()) SWIG_fail;
50309 }
50310 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50311 return resultobj;
50312 fail:
50313 return NULL;
50314 }
50315
50316
50317 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50318 PyObject *resultobj = 0;
50319 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50320 size_t arg2 ;
50321 wxGBSpan result;
50322 void *argp1 = 0 ;
50323 int res1 = 0 ;
50324 size_t val2 ;
50325 int ecode2 = 0 ;
50326
50327 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50329 if (!SWIG_IsOK(res1)) {
50330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50331 }
50332 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50333 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50334 if (!SWIG_IsOK(ecode2)) {
50335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50336 }
50337 arg2 = static_cast< size_t >(val2);
50338 {
50339 PyThreadState* __tstate = wxPyBeginAllowThreads();
50340 result = (arg1)->GetItemSpan(arg2);
50341 wxPyEndAllowThreads(__tstate);
50342 if (PyErr_Occurred()) SWIG_fail;
50343 }
50344 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50345 return resultobj;
50346 fail:
50347 return NULL;
50348 }
50349
50350
50351 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50352 int argc;
50353 PyObject *argv[3];
50354
50355 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50356 --argc;
50357 if (argc == 2) {
50358 int _v = 0;
50359 {
50360 void *vptr = 0;
50361 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50362 _v = SWIG_CheckState(res);
50363 }
50364 if (!_v) goto check_1;
50365 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50366 }
50367 check_1:
50368
50369 if (argc == 2) {
50370 int _v = 0;
50371 {
50372 void *vptr = 0;
50373 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50374 _v = SWIG_CheckState(res);
50375 }
50376 if (!_v) goto check_2;
50377 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50378 }
50379 check_2:
50380
50381 if (argc == 2) {
50382 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50383 }
50384
50385 fail:
50386 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50387 return NULL;
50388 }
50389
50390
50391 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50392 PyObject *resultobj = 0;
50393 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50394 wxWindow *arg2 = (wxWindow *) 0 ;
50395 wxGBSpan *arg3 = 0 ;
50396 bool result;
50397 void *argp1 = 0 ;
50398 int res1 = 0 ;
50399 void *argp2 = 0 ;
50400 int res2 = 0 ;
50401 wxGBSpan temp3 ;
50402
50403 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50405 if (!SWIG_IsOK(res1)) {
50406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50407 }
50408 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50409 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50410 if (!SWIG_IsOK(res2)) {
50411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50412 }
50413 arg2 = reinterpret_cast< wxWindow * >(argp2);
50414 {
50415 arg3 = &temp3;
50416 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50417 }
50418 {
50419 PyThreadState* __tstate = wxPyBeginAllowThreads();
50420 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50421 wxPyEndAllowThreads(__tstate);
50422 if (PyErr_Occurred()) SWIG_fail;
50423 }
50424 {
50425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50426 }
50427 return resultobj;
50428 fail:
50429 return NULL;
50430 }
50431
50432
50433 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50434 PyObject *resultobj = 0;
50435 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50436 wxSizer *arg2 = (wxSizer *) 0 ;
50437 wxGBSpan *arg3 = 0 ;
50438 bool result;
50439 void *argp1 = 0 ;
50440 int res1 = 0 ;
50441 void *argp2 = 0 ;
50442 int res2 = 0 ;
50443 wxGBSpan temp3 ;
50444
50445 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50447 if (!SWIG_IsOK(res1)) {
50448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50449 }
50450 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50451 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50452 if (!SWIG_IsOK(res2)) {
50453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50454 }
50455 arg2 = reinterpret_cast< wxSizer * >(argp2);
50456 {
50457 arg3 = &temp3;
50458 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50459 }
50460 {
50461 PyThreadState* __tstate = wxPyBeginAllowThreads();
50462 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50463 wxPyEndAllowThreads(__tstate);
50464 if (PyErr_Occurred()) SWIG_fail;
50465 }
50466 {
50467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50468 }
50469 return resultobj;
50470 fail:
50471 return NULL;
50472 }
50473
50474
50475 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50476 PyObject *resultobj = 0;
50477 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50478 size_t arg2 ;
50479 wxGBSpan *arg3 = 0 ;
50480 bool result;
50481 void *argp1 = 0 ;
50482 int res1 = 0 ;
50483 size_t val2 ;
50484 int ecode2 = 0 ;
50485 wxGBSpan temp3 ;
50486
50487 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50489 if (!SWIG_IsOK(res1)) {
50490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50491 }
50492 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50493 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50494 if (!SWIG_IsOK(ecode2)) {
50495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50496 }
50497 arg2 = static_cast< size_t >(val2);
50498 {
50499 arg3 = &temp3;
50500 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50501 }
50502 {
50503 PyThreadState* __tstate = wxPyBeginAllowThreads();
50504 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50505 wxPyEndAllowThreads(__tstate);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 {
50509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50510 }
50511 return resultobj;
50512 fail:
50513 return NULL;
50514 }
50515
50516
50517 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50518 int argc;
50519 PyObject *argv[4];
50520
50521 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50522 --argc;
50523 if (argc == 3) {
50524 int _v = 0;
50525 {
50526 void *vptr = 0;
50527 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50528 _v = SWIG_CheckState(res);
50529 }
50530 if (!_v) goto check_1;
50531 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50532 }
50533 check_1:
50534
50535 if (argc == 3) {
50536 int _v = 0;
50537 {
50538 void *vptr = 0;
50539 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50540 _v = SWIG_CheckState(res);
50541 }
50542 if (!_v) goto check_2;
50543 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50544 }
50545 check_2:
50546
50547 if (argc == 3) {
50548 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50549 }
50550
50551 fail:
50552 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50553 return NULL;
50554 }
50555
50556
50557 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50558 PyObject *resultobj = 0;
50559 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50560 wxWindow *arg2 = (wxWindow *) 0 ;
50561 wxGBSizerItem *result = 0 ;
50562 void *argp1 = 0 ;
50563 int res1 = 0 ;
50564 void *argp2 = 0 ;
50565 int res2 = 0 ;
50566
50567 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50569 if (!SWIG_IsOK(res1)) {
50570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50571 }
50572 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50574 if (!SWIG_IsOK(res2)) {
50575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50576 }
50577 arg2 = reinterpret_cast< wxWindow * >(argp2);
50578 {
50579 PyThreadState* __tstate = wxPyBeginAllowThreads();
50580 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50581 wxPyEndAllowThreads(__tstate);
50582 if (PyErr_Occurred()) SWIG_fail;
50583 }
50584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50585 return resultobj;
50586 fail:
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50592 PyObject *resultobj = 0;
50593 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50594 wxSizer *arg2 = (wxSizer *) 0 ;
50595 wxGBSizerItem *result = 0 ;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 void *argp2 = 0 ;
50599 int res2 = 0 ;
50600
50601 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50603 if (!SWIG_IsOK(res1)) {
50604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50605 }
50606 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50607 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50608 if (!SWIG_IsOK(res2)) {
50609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50610 }
50611 arg2 = reinterpret_cast< wxSizer * >(argp2);
50612 {
50613 PyThreadState* __tstate = wxPyBeginAllowThreads();
50614 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50615 wxPyEndAllowThreads(__tstate);
50616 if (PyErr_Occurred()) SWIG_fail;
50617 }
50618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50619 return resultobj;
50620 fail:
50621 return NULL;
50622 }
50623
50624
50625 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50626 int argc;
50627 PyObject *argv[3];
50628
50629 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50630 --argc;
50631 if (argc == 2) {
50632 int _v = 0;
50633 {
50634 void *vptr = 0;
50635 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50636 _v = SWIG_CheckState(res);
50637 }
50638 if (!_v) goto check_1;
50639 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50640 }
50641 check_1:
50642
50643 if (argc == 2) {
50644 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50645 }
50646
50647 fail:
50648 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50649 return NULL;
50650 }
50651
50652
50653 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50654 PyObject *resultobj = 0;
50655 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50656 wxGBPosition *arg2 = 0 ;
50657 wxGBSizerItem *result = 0 ;
50658 void *argp1 = 0 ;
50659 int res1 = 0 ;
50660 wxGBPosition temp2 ;
50661 PyObject * obj0 = 0 ;
50662 PyObject * obj1 = 0 ;
50663 char * kwnames[] = {
50664 (char *) "self",(char *) "pos", NULL
50665 };
50666
50667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50669 if (!SWIG_IsOK(res1)) {
50670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50671 }
50672 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50673 {
50674 arg2 = &temp2;
50675 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50676 }
50677 {
50678 PyThreadState* __tstate = wxPyBeginAllowThreads();
50679 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50680 wxPyEndAllowThreads(__tstate);
50681 if (PyErr_Occurred()) SWIG_fail;
50682 }
50683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50691 PyObject *resultobj = 0;
50692 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50693 wxPoint *arg2 = 0 ;
50694 wxGBSizerItem *result = 0 ;
50695 void *argp1 = 0 ;
50696 int res1 = 0 ;
50697 wxPoint temp2 ;
50698 PyObject * obj0 = 0 ;
50699 PyObject * obj1 = 0 ;
50700 char * kwnames[] = {
50701 (char *) "self",(char *) "pt", NULL
50702 };
50703
50704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50708 }
50709 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50710 {
50711 arg2 = &temp2;
50712 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50713 }
50714 {
50715 PyThreadState* __tstate = wxPyBeginAllowThreads();
50716 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50717 wxPyEndAllowThreads(__tstate);
50718 if (PyErr_Occurred()) SWIG_fail;
50719 }
50720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50721 return resultobj;
50722 fail:
50723 return NULL;
50724 }
50725
50726
50727 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50728 PyObject *resultobj = 0;
50729 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50730 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50731 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50732 bool result;
50733 void *argp1 = 0 ;
50734 int res1 = 0 ;
50735 void *argp2 = 0 ;
50736 int res2 = 0 ;
50737 void *argp3 = 0 ;
50738 int res3 = 0 ;
50739 PyObject * obj0 = 0 ;
50740 PyObject * obj1 = 0 ;
50741 PyObject * obj2 = 0 ;
50742 char * kwnames[] = {
50743 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50744 };
50745
50746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50748 if (!SWIG_IsOK(res1)) {
50749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50750 }
50751 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50753 if (!SWIG_IsOK(res2)) {
50754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50755 }
50756 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50757 if (obj2) {
50758 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50759 if (!SWIG_IsOK(res3)) {
50760 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50761 }
50762 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50763 }
50764 {
50765 PyThreadState* __tstate = wxPyBeginAllowThreads();
50766 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50767 wxPyEndAllowThreads(__tstate);
50768 if (PyErr_Occurred()) SWIG_fail;
50769 }
50770 {
50771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50772 }
50773 return resultobj;
50774 fail:
50775 return NULL;
50776 }
50777
50778
50779 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50780 PyObject *resultobj = 0;
50781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50782 wxGBPosition *arg2 = 0 ;
50783 wxGBSpan *arg3 = 0 ;
50784 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50785 bool result;
50786 void *argp1 = 0 ;
50787 int res1 = 0 ;
50788 wxGBPosition temp2 ;
50789 wxGBSpan temp3 ;
50790 void *argp4 = 0 ;
50791 int res4 = 0 ;
50792 PyObject * obj0 = 0 ;
50793 PyObject * obj1 = 0 ;
50794 PyObject * obj2 = 0 ;
50795 PyObject * obj3 = 0 ;
50796 char * kwnames[] = {
50797 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50798 };
50799
50800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50802 if (!SWIG_IsOK(res1)) {
50803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50804 }
50805 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50806 {
50807 arg2 = &temp2;
50808 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50809 }
50810 {
50811 arg3 = &temp3;
50812 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50813 }
50814 if (obj3) {
50815 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50816 if (!SWIG_IsOK(res4)) {
50817 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50818 }
50819 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50820 }
50821 {
50822 PyThreadState* __tstate = wxPyBeginAllowThreads();
50823 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50824 wxPyEndAllowThreads(__tstate);
50825 if (PyErr_Occurred()) SWIG_fail;
50826 }
50827 {
50828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50829 }
50830 return resultobj;
50831 fail:
50832 return NULL;
50833 }
50834
50835
50836 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50837 PyObject *obj;
50838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50839 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50840 return SWIG_Py_Void();
50841 }
50842
50843 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50844 return SWIG_Python_InitShadowInstance(args);
50845 }
50846
50847 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50848 PyObject *resultobj = 0;
50849 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50850 wxRelationship arg2 ;
50851 wxWindow *arg3 = (wxWindow *) 0 ;
50852 wxEdge arg4 ;
50853 int arg5 = (int) 0 ;
50854 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50855 void *argp1 = 0 ;
50856 int res1 = 0 ;
50857 int val2 ;
50858 int ecode2 = 0 ;
50859 void *argp3 = 0 ;
50860 int res3 = 0 ;
50861 int val4 ;
50862 int ecode4 = 0 ;
50863 int val5 ;
50864 int ecode5 = 0 ;
50865 int val6 ;
50866 int ecode6 = 0 ;
50867 PyObject * obj0 = 0 ;
50868 PyObject * obj1 = 0 ;
50869 PyObject * obj2 = 0 ;
50870 PyObject * obj3 = 0 ;
50871 PyObject * obj4 = 0 ;
50872 PyObject * obj5 = 0 ;
50873 char * kwnames[] = {
50874 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
50875 };
50876
50877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50879 if (!SWIG_IsOK(res1)) {
50880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50881 }
50882 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50883 ecode2 = SWIG_AsVal_int(obj1, &val2);
50884 if (!SWIG_IsOK(ecode2)) {
50885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
50886 }
50887 arg2 = static_cast< wxRelationship >(val2);
50888 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50889 if (!SWIG_IsOK(res3)) {
50890 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
50891 }
50892 arg3 = reinterpret_cast< wxWindow * >(argp3);
50893 ecode4 = SWIG_AsVal_int(obj3, &val4);
50894 if (!SWIG_IsOK(ecode4)) {
50895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
50896 }
50897 arg4 = static_cast< wxEdge >(val4);
50898 if (obj4) {
50899 ecode5 = SWIG_AsVal_int(obj4, &val5);
50900 if (!SWIG_IsOK(ecode5)) {
50901 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
50902 }
50903 arg5 = static_cast< int >(val5);
50904 }
50905 if (obj5) {
50906 ecode6 = SWIG_AsVal_int(obj5, &val6);
50907 if (!SWIG_IsOK(ecode6)) {
50908 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
50909 }
50910 arg6 = static_cast< int >(val6);
50911 }
50912 {
50913 PyThreadState* __tstate = wxPyBeginAllowThreads();
50914 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
50915 wxPyEndAllowThreads(__tstate);
50916 if (PyErr_Occurred()) SWIG_fail;
50917 }
50918 resultobj = SWIG_Py_Void();
50919 return resultobj;
50920 fail:
50921 return NULL;
50922 }
50923
50924
50925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50926 PyObject *resultobj = 0;
50927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50928 wxWindow *arg2 = (wxWindow *) 0 ;
50929 int arg3 = (int) 0 ;
50930 void *argp1 = 0 ;
50931 int res1 = 0 ;
50932 void *argp2 = 0 ;
50933 int res2 = 0 ;
50934 int val3 ;
50935 int ecode3 = 0 ;
50936 PyObject * obj0 = 0 ;
50937 PyObject * obj1 = 0 ;
50938 PyObject * obj2 = 0 ;
50939 char * kwnames[] = {
50940 (char *) "self",(char *) "sibling",(char *) "marg", NULL
50941 };
50942
50943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50945 if (!SWIG_IsOK(res1)) {
50946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50947 }
50948 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50950 if (!SWIG_IsOK(res2)) {
50951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
50952 }
50953 arg2 = reinterpret_cast< wxWindow * >(argp2);
50954 if (obj2) {
50955 ecode3 = SWIG_AsVal_int(obj2, &val3);
50956 if (!SWIG_IsOK(ecode3)) {
50957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
50958 }
50959 arg3 = static_cast< int >(val3);
50960 }
50961 {
50962 PyThreadState* __tstate = wxPyBeginAllowThreads();
50963 (arg1)->LeftOf(arg2,arg3);
50964 wxPyEndAllowThreads(__tstate);
50965 if (PyErr_Occurred()) SWIG_fail;
50966 }
50967 resultobj = SWIG_Py_Void();
50968 return resultobj;
50969 fail:
50970 return NULL;
50971 }
50972
50973
50974 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50975 PyObject *resultobj = 0;
50976 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50977 wxWindow *arg2 = (wxWindow *) 0 ;
50978 int arg3 = (int) 0 ;
50979 void *argp1 = 0 ;
50980 int res1 = 0 ;
50981 void *argp2 = 0 ;
50982 int res2 = 0 ;
50983 int val3 ;
50984 int ecode3 = 0 ;
50985 PyObject * obj0 = 0 ;
50986 PyObject * obj1 = 0 ;
50987 PyObject * obj2 = 0 ;
50988 char * kwnames[] = {
50989 (char *) "self",(char *) "sibling",(char *) "marg", NULL
50990 };
50991
50992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50994 if (!SWIG_IsOK(res1)) {
50995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50996 }
50997 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50999 if (!SWIG_IsOK(res2)) {
51000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51001 }
51002 arg2 = reinterpret_cast< wxWindow * >(argp2);
51003 if (obj2) {
51004 ecode3 = SWIG_AsVal_int(obj2, &val3);
51005 if (!SWIG_IsOK(ecode3)) {
51006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51007 }
51008 arg3 = static_cast< int >(val3);
51009 }
51010 {
51011 PyThreadState* __tstate = wxPyBeginAllowThreads();
51012 (arg1)->RightOf(arg2,arg3);
51013 wxPyEndAllowThreads(__tstate);
51014 if (PyErr_Occurred()) SWIG_fail;
51015 }
51016 resultobj = SWIG_Py_Void();
51017 return resultobj;
51018 fail:
51019 return NULL;
51020 }
51021
51022
51023 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51024 PyObject *resultobj = 0;
51025 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51026 wxWindow *arg2 = (wxWindow *) 0 ;
51027 int arg3 = (int) 0 ;
51028 void *argp1 = 0 ;
51029 int res1 = 0 ;
51030 void *argp2 = 0 ;
51031 int res2 = 0 ;
51032 int val3 ;
51033 int ecode3 = 0 ;
51034 PyObject * obj0 = 0 ;
51035 PyObject * obj1 = 0 ;
51036 PyObject * obj2 = 0 ;
51037 char * kwnames[] = {
51038 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51039 };
51040
51041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51043 if (!SWIG_IsOK(res1)) {
51044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51045 }
51046 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51047 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51048 if (!SWIG_IsOK(res2)) {
51049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51050 }
51051 arg2 = reinterpret_cast< wxWindow * >(argp2);
51052 if (obj2) {
51053 ecode3 = SWIG_AsVal_int(obj2, &val3);
51054 if (!SWIG_IsOK(ecode3)) {
51055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51056 }
51057 arg3 = static_cast< int >(val3);
51058 }
51059 {
51060 PyThreadState* __tstate = wxPyBeginAllowThreads();
51061 (arg1)->Above(arg2,arg3);
51062 wxPyEndAllowThreads(__tstate);
51063 if (PyErr_Occurred()) SWIG_fail;
51064 }
51065 resultobj = SWIG_Py_Void();
51066 return resultobj;
51067 fail:
51068 return NULL;
51069 }
51070
51071
51072 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51073 PyObject *resultobj = 0;
51074 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51075 wxWindow *arg2 = (wxWindow *) 0 ;
51076 int arg3 = (int) 0 ;
51077 void *argp1 = 0 ;
51078 int res1 = 0 ;
51079 void *argp2 = 0 ;
51080 int res2 = 0 ;
51081 int val3 ;
51082 int ecode3 = 0 ;
51083 PyObject * obj0 = 0 ;
51084 PyObject * obj1 = 0 ;
51085 PyObject * obj2 = 0 ;
51086 char * kwnames[] = {
51087 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51088 };
51089
51090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51092 if (!SWIG_IsOK(res1)) {
51093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51094 }
51095 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51097 if (!SWIG_IsOK(res2)) {
51098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51099 }
51100 arg2 = reinterpret_cast< wxWindow * >(argp2);
51101 if (obj2) {
51102 ecode3 = SWIG_AsVal_int(obj2, &val3);
51103 if (!SWIG_IsOK(ecode3)) {
51104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51105 }
51106 arg3 = static_cast< int >(val3);
51107 }
51108 {
51109 PyThreadState* __tstate = wxPyBeginAllowThreads();
51110 (arg1)->Below(arg2,arg3);
51111 wxPyEndAllowThreads(__tstate);
51112 if (PyErr_Occurred()) SWIG_fail;
51113 }
51114 resultobj = SWIG_Py_Void();
51115 return resultobj;
51116 fail:
51117 return NULL;
51118 }
51119
51120
51121 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51122 PyObject *resultobj = 0;
51123 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51124 wxWindow *arg2 = (wxWindow *) 0 ;
51125 wxEdge arg3 ;
51126 int arg4 = (int) 0 ;
51127 void *argp1 = 0 ;
51128 int res1 = 0 ;
51129 void *argp2 = 0 ;
51130 int res2 = 0 ;
51131 int val3 ;
51132 int ecode3 = 0 ;
51133 int val4 ;
51134 int ecode4 = 0 ;
51135 PyObject * obj0 = 0 ;
51136 PyObject * obj1 = 0 ;
51137 PyObject * obj2 = 0 ;
51138 PyObject * obj3 = 0 ;
51139 char * kwnames[] = {
51140 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51141 };
51142
51143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51145 if (!SWIG_IsOK(res1)) {
51146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51147 }
51148 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51150 if (!SWIG_IsOK(res2)) {
51151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51152 }
51153 arg2 = reinterpret_cast< wxWindow * >(argp2);
51154 ecode3 = SWIG_AsVal_int(obj2, &val3);
51155 if (!SWIG_IsOK(ecode3)) {
51156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51157 }
51158 arg3 = static_cast< wxEdge >(val3);
51159 if (obj3) {
51160 ecode4 = SWIG_AsVal_int(obj3, &val4);
51161 if (!SWIG_IsOK(ecode4)) {
51162 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51163 }
51164 arg4 = static_cast< int >(val4);
51165 }
51166 {
51167 PyThreadState* __tstate = wxPyBeginAllowThreads();
51168 (arg1)->SameAs(arg2,arg3,arg4);
51169 wxPyEndAllowThreads(__tstate);
51170 if (PyErr_Occurred()) SWIG_fail;
51171 }
51172 resultobj = SWIG_Py_Void();
51173 return resultobj;
51174 fail:
51175 return NULL;
51176 }
51177
51178
51179 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51180 PyObject *resultobj = 0;
51181 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51182 wxWindow *arg2 = (wxWindow *) 0 ;
51183 wxEdge arg3 ;
51184 int arg4 ;
51185 void *argp1 = 0 ;
51186 int res1 = 0 ;
51187 void *argp2 = 0 ;
51188 int res2 = 0 ;
51189 int val3 ;
51190 int ecode3 = 0 ;
51191 int val4 ;
51192 int ecode4 = 0 ;
51193 PyObject * obj0 = 0 ;
51194 PyObject * obj1 = 0 ;
51195 PyObject * obj2 = 0 ;
51196 PyObject * obj3 = 0 ;
51197 char * kwnames[] = {
51198 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51199 };
51200
51201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51203 if (!SWIG_IsOK(res1)) {
51204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51205 }
51206 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51208 if (!SWIG_IsOK(res2)) {
51209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51210 }
51211 arg2 = reinterpret_cast< wxWindow * >(argp2);
51212 ecode3 = SWIG_AsVal_int(obj2, &val3);
51213 if (!SWIG_IsOK(ecode3)) {
51214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51215 }
51216 arg3 = static_cast< wxEdge >(val3);
51217 ecode4 = SWIG_AsVal_int(obj3, &val4);
51218 if (!SWIG_IsOK(ecode4)) {
51219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51220 }
51221 arg4 = static_cast< int >(val4);
51222 {
51223 PyThreadState* __tstate = wxPyBeginAllowThreads();
51224 (arg1)->PercentOf(arg2,arg3,arg4);
51225 wxPyEndAllowThreads(__tstate);
51226 if (PyErr_Occurred()) SWIG_fail;
51227 }
51228 resultobj = SWIG_Py_Void();
51229 return resultobj;
51230 fail:
51231 return NULL;
51232 }
51233
51234
51235 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51236 PyObject *resultobj = 0;
51237 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51238 int arg2 ;
51239 void *argp1 = 0 ;
51240 int res1 = 0 ;
51241 int val2 ;
51242 int ecode2 = 0 ;
51243 PyObject * obj0 = 0 ;
51244 PyObject * obj1 = 0 ;
51245 char * kwnames[] = {
51246 (char *) "self",(char *) "val", NULL
51247 };
51248
51249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51251 if (!SWIG_IsOK(res1)) {
51252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51253 }
51254 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51255 ecode2 = SWIG_AsVal_int(obj1, &val2);
51256 if (!SWIG_IsOK(ecode2)) {
51257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51258 }
51259 arg2 = static_cast< int >(val2);
51260 {
51261 PyThreadState* __tstate = wxPyBeginAllowThreads();
51262 (arg1)->Absolute(arg2);
51263 wxPyEndAllowThreads(__tstate);
51264 if (PyErr_Occurred()) SWIG_fail;
51265 }
51266 resultobj = SWIG_Py_Void();
51267 return resultobj;
51268 fail:
51269 return NULL;
51270 }
51271
51272
51273 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51274 PyObject *resultobj = 0;
51275 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51276 void *argp1 = 0 ;
51277 int res1 = 0 ;
51278 PyObject *swig_obj[1] ;
51279
51280 if (!args) SWIG_fail;
51281 swig_obj[0] = args;
51282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51283 if (!SWIG_IsOK(res1)) {
51284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51285 }
51286 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51287 {
51288 PyThreadState* __tstate = wxPyBeginAllowThreads();
51289 (arg1)->Unconstrained();
51290 wxPyEndAllowThreads(__tstate);
51291 if (PyErr_Occurred()) SWIG_fail;
51292 }
51293 resultobj = SWIG_Py_Void();
51294 return resultobj;
51295 fail:
51296 return NULL;
51297 }
51298
51299
51300 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51301 PyObject *resultobj = 0;
51302 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51303 void *argp1 = 0 ;
51304 int res1 = 0 ;
51305 PyObject *swig_obj[1] ;
51306
51307 if (!args) SWIG_fail;
51308 swig_obj[0] = args;
51309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51310 if (!SWIG_IsOK(res1)) {
51311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51312 }
51313 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51314 {
51315 PyThreadState* __tstate = wxPyBeginAllowThreads();
51316 (arg1)->AsIs();
51317 wxPyEndAllowThreads(__tstate);
51318 if (PyErr_Occurred()) SWIG_fail;
51319 }
51320 resultobj = SWIG_Py_Void();
51321 return resultobj;
51322 fail:
51323 return NULL;
51324 }
51325
51326
51327 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51328 PyObject *resultobj = 0;
51329 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51330 wxWindow *result = 0 ;
51331 void *argp1 = 0 ;
51332 int res1 = 0 ;
51333 PyObject *swig_obj[1] ;
51334
51335 if (!args) SWIG_fail;
51336 swig_obj[0] = args;
51337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51338 if (!SWIG_IsOK(res1)) {
51339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51340 }
51341 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51342 {
51343 PyThreadState* __tstate = wxPyBeginAllowThreads();
51344 result = (wxWindow *)(arg1)->GetOtherWindow();
51345 wxPyEndAllowThreads(__tstate);
51346 if (PyErr_Occurred()) SWIG_fail;
51347 }
51348 {
51349 resultobj = wxPyMake_wxObject(result, 0);
51350 }
51351 return resultobj;
51352 fail:
51353 return NULL;
51354 }
51355
51356
51357 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51358 PyObject *resultobj = 0;
51359 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51360 wxEdge result;
51361 void *argp1 = 0 ;
51362 int res1 = 0 ;
51363 PyObject *swig_obj[1] ;
51364
51365 if (!args) SWIG_fail;
51366 swig_obj[0] = args;
51367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51368 if (!SWIG_IsOK(res1)) {
51369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51370 }
51371 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51372 {
51373 PyThreadState* __tstate = wxPyBeginAllowThreads();
51374 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51375 wxPyEndAllowThreads(__tstate);
51376 if (PyErr_Occurred()) SWIG_fail;
51377 }
51378 resultobj = SWIG_From_int(static_cast< int >(result));
51379 return resultobj;
51380 fail:
51381 return NULL;
51382 }
51383
51384
51385 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51386 PyObject *resultobj = 0;
51387 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51388 wxEdge arg2 ;
51389 void *argp1 = 0 ;
51390 int res1 = 0 ;
51391 int val2 ;
51392 int ecode2 = 0 ;
51393 PyObject * obj0 = 0 ;
51394 PyObject * obj1 = 0 ;
51395 char * kwnames[] = {
51396 (char *) "self",(char *) "which", NULL
51397 };
51398
51399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51401 if (!SWIG_IsOK(res1)) {
51402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51403 }
51404 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51405 ecode2 = SWIG_AsVal_int(obj1, &val2);
51406 if (!SWIG_IsOK(ecode2)) {
51407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51408 }
51409 arg2 = static_cast< wxEdge >(val2);
51410 {
51411 PyThreadState* __tstate = wxPyBeginAllowThreads();
51412 (arg1)->SetEdge(arg2);
51413 wxPyEndAllowThreads(__tstate);
51414 if (PyErr_Occurred()) SWIG_fail;
51415 }
51416 resultobj = SWIG_Py_Void();
51417 return resultobj;
51418 fail:
51419 return NULL;
51420 }
51421
51422
51423 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51424 PyObject *resultobj = 0;
51425 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51426 int arg2 ;
51427 void *argp1 = 0 ;
51428 int res1 = 0 ;
51429 int val2 ;
51430 int ecode2 = 0 ;
51431 PyObject * obj0 = 0 ;
51432 PyObject * obj1 = 0 ;
51433 char * kwnames[] = {
51434 (char *) "self",(char *) "v", NULL
51435 };
51436
51437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51439 if (!SWIG_IsOK(res1)) {
51440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51441 }
51442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51443 ecode2 = SWIG_AsVal_int(obj1, &val2);
51444 if (!SWIG_IsOK(ecode2)) {
51445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51446 }
51447 arg2 = static_cast< int >(val2);
51448 {
51449 PyThreadState* __tstate = wxPyBeginAllowThreads();
51450 (arg1)->SetValue(arg2);
51451 wxPyEndAllowThreads(__tstate);
51452 if (PyErr_Occurred()) SWIG_fail;
51453 }
51454 resultobj = SWIG_Py_Void();
51455 return resultobj;
51456 fail:
51457 return NULL;
51458 }
51459
51460
51461 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51462 PyObject *resultobj = 0;
51463 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51464 int result;
51465 void *argp1 = 0 ;
51466 int res1 = 0 ;
51467 PyObject *swig_obj[1] ;
51468
51469 if (!args) SWIG_fail;
51470 swig_obj[0] = args;
51471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51472 if (!SWIG_IsOK(res1)) {
51473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51474 }
51475 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51476 {
51477 PyThreadState* __tstate = wxPyBeginAllowThreads();
51478 result = (int)(arg1)->GetMargin();
51479 wxPyEndAllowThreads(__tstate);
51480 if (PyErr_Occurred()) SWIG_fail;
51481 }
51482 resultobj = SWIG_From_int(static_cast< int >(result));
51483 return resultobj;
51484 fail:
51485 return NULL;
51486 }
51487
51488
51489 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51490 PyObject *resultobj = 0;
51491 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51492 int arg2 ;
51493 void *argp1 = 0 ;
51494 int res1 = 0 ;
51495 int val2 ;
51496 int ecode2 = 0 ;
51497 PyObject * obj0 = 0 ;
51498 PyObject * obj1 = 0 ;
51499 char * kwnames[] = {
51500 (char *) "self",(char *) "m", NULL
51501 };
51502
51503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51505 if (!SWIG_IsOK(res1)) {
51506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51507 }
51508 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51509 ecode2 = SWIG_AsVal_int(obj1, &val2);
51510 if (!SWIG_IsOK(ecode2)) {
51511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51512 }
51513 arg2 = static_cast< int >(val2);
51514 {
51515 PyThreadState* __tstate = wxPyBeginAllowThreads();
51516 (arg1)->SetMargin(arg2);
51517 wxPyEndAllowThreads(__tstate);
51518 if (PyErr_Occurred()) SWIG_fail;
51519 }
51520 resultobj = SWIG_Py_Void();
51521 return resultobj;
51522 fail:
51523 return NULL;
51524 }
51525
51526
51527 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51528 PyObject *resultobj = 0;
51529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51530 int result;
51531 void *argp1 = 0 ;
51532 int res1 = 0 ;
51533 PyObject *swig_obj[1] ;
51534
51535 if (!args) SWIG_fail;
51536 swig_obj[0] = args;
51537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51538 if (!SWIG_IsOK(res1)) {
51539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51540 }
51541 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51542 {
51543 PyThreadState* __tstate = wxPyBeginAllowThreads();
51544 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51545 wxPyEndAllowThreads(__tstate);
51546 if (PyErr_Occurred()) SWIG_fail;
51547 }
51548 resultobj = SWIG_From_int(static_cast< int >(result));
51549 return resultobj;
51550 fail:
51551 return NULL;
51552 }
51553
51554
51555 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51556 PyObject *resultobj = 0;
51557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51558 int result;
51559 void *argp1 = 0 ;
51560 int res1 = 0 ;
51561 PyObject *swig_obj[1] ;
51562
51563 if (!args) SWIG_fail;
51564 swig_obj[0] = args;
51565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51566 if (!SWIG_IsOK(res1)) {
51567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51568 }
51569 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51570 {
51571 PyThreadState* __tstate = wxPyBeginAllowThreads();
51572 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51573 wxPyEndAllowThreads(__tstate);
51574 if (PyErr_Occurred()) SWIG_fail;
51575 }
51576 resultobj = SWIG_From_int(static_cast< int >(result));
51577 return resultobj;
51578 fail:
51579 return NULL;
51580 }
51581
51582
51583 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51584 PyObject *resultobj = 0;
51585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51586 int result;
51587 void *argp1 = 0 ;
51588 int res1 = 0 ;
51589 PyObject *swig_obj[1] ;
51590
51591 if (!args) SWIG_fail;
51592 swig_obj[0] = args;
51593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51594 if (!SWIG_IsOK(res1)) {
51595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51596 }
51597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51598 {
51599 PyThreadState* __tstate = wxPyBeginAllowThreads();
51600 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51601 wxPyEndAllowThreads(__tstate);
51602 if (PyErr_Occurred()) SWIG_fail;
51603 }
51604 resultobj = SWIG_From_int(static_cast< int >(result));
51605 return resultobj;
51606 fail:
51607 return NULL;
51608 }
51609
51610
51611 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51612 PyObject *resultobj = 0;
51613 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51614 bool result;
51615 void *argp1 = 0 ;
51616 int res1 = 0 ;
51617 PyObject *swig_obj[1] ;
51618
51619 if (!args) SWIG_fail;
51620 swig_obj[0] = args;
51621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51622 if (!SWIG_IsOK(res1)) {
51623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51624 }
51625 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51626 {
51627 PyThreadState* __tstate = wxPyBeginAllowThreads();
51628 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51629 wxPyEndAllowThreads(__tstate);
51630 if (PyErr_Occurred()) SWIG_fail;
51631 }
51632 {
51633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51634 }
51635 return resultobj;
51636 fail:
51637 return NULL;
51638 }
51639
51640
51641 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51642 PyObject *resultobj = 0;
51643 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51644 bool arg2 ;
51645 void *argp1 = 0 ;
51646 int res1 = 0 ;
51647 bool val2 ;
51648 int ecode2 = 0 ;
51649 PyObject * obj0 = 0 ;
51650 PyObject * obj1 = 0 ;
51651 char * kwnames[] = {
51652 (char *) "self",(char *) "d", NULL
51653 };
51654
51655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51657 if (!SWIG_IsOK(res1)) {
51658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51659 }
51660 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51661 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51662 if (!SWIG_IsOK(ecode2)) {
51663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51664 }
51665 arg2 = static_cast< bool >(val2);
51666 {
51667 PyThreadState* __tstate = wxPyBeginAllowThreads();
51668 (arg1)->SetDone(arg2);
51669 wxPyEndAllowThreads(__tstate);
51670 if (PyErr_Occurred()) SWIG_fail;
51671 }
51672 resultobj = SWIG_Py_Void();
51673 return resultobj;
51674 fail:
51675 return NULL;
51676 }
51677
51678
51679 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51680 PyObject *resultobj = 0;
51681 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51682 wxRelationship result;
51683 void *argp1 = 0 ;
51684 int res1 = 0 ;
51685 PyObject *swig_obj[1] ;
51686
51687 if (!args) SWIG_fail;
51688 swig_obj[0] = args;
51689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51690 if (!SWIG_IsOK(res1)) {
51691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51692 }
51693 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51694 {
51695 PyThreadState* __tstate = wxPyBeginAllowThreads();
51696 result = (wxRelationship)(arg1)->GetRelationship();
51697 wxPyEndAllowThreads(__tstate);
51698 if (PyErr_Occurred()) SWIG_fail;
51699 }
51700 resultobj = SWIG_From_int(static_cast< int >(result));
51701 return resultobj;
51702 fail:
51703 return NULL;
51704 }
51705
51706
51707 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51708 PyObject *resultobj = 0;
51709 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51710 wxRelationship arg2 ;
51711 void *argp1 = 0 ;
51712 int res1 = 0 ;
51713 int val2 ;
51714 int ecode2 = 0 ;
51715 PyObject * obj0 = 0 ;
51716 PyObject * obj1 = 0 ;
51717 char * kwnames[] = {
51718 (char *) "self",(char *) "r", NULL
51719 };
51720
51721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51725 }
51726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51727 ecode2 = SWIG_AsVal_int(obj1, &val2);
51728 if (!SWIG_IsOK(ecode2)) {
51729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51730 }
51731 arg2 = static_cast< wxRelationship >(val2);
51732 {
51733 PyThreadState* __tstate = wxPyBeginAllowThreads();
51734 (arg1)->SetRelationship(arg2);
51735 wxPyEndAllowThreads(__tstate);
51736 if (PyErr_Occurred()) SWIG_fail;
51737 }
51738 resultobj = SWIG_Py_Void();
51739 return resultobj;
51740 fail:
51741 return NULL;
51742 }
51743
51744
51745 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51746 PyObject *resultobj = 0;
51747 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51748 wxWindow *arg2 = (wxWindow *) 0 ;
51749 bool result;
51750 void *argp1 = 0 ;
51751 int res1 = 0 ;
51752 void *argp2 = 0 ;
51753 int res2 = 0 ;
51754 PyObject * obj0 = 0 ;
51755 PyObject * obj1 = 0 ;
51756 char * kwnames[] = {
51757 (char *) "self",(char *) "otherW", NULL
51758 };
51759
51760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51762 if (!SWIG_IsOK(res1)) {
51763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51764 }
51765 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51767 if (!SWIG_IsOK(res2)) {
51768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51769 }
51770 arg2 = reinterpret_cast< wxWindow * >(argp2);
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 result = (bool)(arg1)->ResetIfWin(arg2);
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 {
51778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51779 }
51780 return resultobj;
51781 fail:
51782 return NULL;
51783 }
51784
51785
51786 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51787 PyObject *resultobj = 0;
51788 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51789 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51790 wxWindow *arg3 = (wxWindow *) 0 ;
51791 bool result;
51792 void *argp1 = 0 ;
51793 int res1 = 0 ;
51794 void *argp2 = 0 ;
51795 int res2 = 0 ;
51796 void *argp3 = 0 ;
51797 int res3 = 0 ;
51798 PyObject * obj0 = 0 ;
51799 PyObject * obj1 = 0 ;
51800 PyObject * obj2 = 0 ;
51801 char * kwnames[] = {
51802 (char *) "self",(char *) "constraints",(char *) "win", NULL
51803 };
51804
51805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51807 if (!SWIG_IsOK(res1)) {
51808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51809 }
51810 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51812 if (!SWIG_IsOK(res2)) {
51813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51814 }
51815 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51816 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51817 if (!SWIG_IsOK(res3)) {
51818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51819 }
51820 arg3 = reinterpret_cast< wxWindow * >(argp3);
51821 {
51822 PyThreadState* __tstate = wxPyBeginAllowThreads();
51823 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51824 wxPyEndAllowThreads(__tstate);
51825 if (PyErr_Occurred()) SWIG_fail;
51826 }
51827 {
51828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51829 }
51830 return resultobj;
51831 fail:
51832 return NULL;
51833 }
51834
51835
51836 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51837 PyObject *resultobj = 0;
51838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51839 wxEdge arg2 ;
51840 wxWindow *arg3 = (wxWindow *) 0 ;
51841 wxWindow *arg4 = (wxWindow *) 0 ;
51842 int result;
51843 void *argp1 = 0 ;
51844 int res1 = 0 ;
51845 int val2 ;
51846 int ecode2 = 0 ;
51847 void *argp3 = 0 ;
51848 int res3 = 0 ;
51849 void *argp4 = 0 ;
51850 int res4 = 0 ;
51851 PyObject * obj0 = 0 ;
51852 PyObject * obj1 = 0 ;
51853 PyObject * obj2 = 0 ;
51854 PyObject * obj3 = 0 ;
51855 char * kwnames[] = {
51856 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51857 };
51858
51859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51861 if (!SWIG_IsOK(res1)) {
51862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51863 }
51864 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51865 ecode2 = SWIG_AsVal_int(obj1, &val2);
51866 if (!SWIG_IsOK(ecode2)) {
51867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51868 }
51869 arg2 = static_cast< wxEdge >(val2);
51870 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51871 if (!SWIG_IsOK(res3)) {
51872 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
51873 }
51874 arg3 = reinterpret_cast< wxWindow * >(argp3);
51875 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
51876 if (!SWIG_IsOK(res4)) {
51877 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
51878 }
51879 arg4 = reinterpret_cast< wxWindow * >(argp4);
51880 {
51881 PyThreadState* __tstate = wxPyBeginAllowThreads();
51882 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
51883 wxPyEndAllowThreads(__tstate);
51884 if (PyErr_Occurred()) SWIG_fail;
51885 }
51886 resultobj = SWIG_From_int(static_cast< int >(result));
51887 return resultobj;
51888 fail:
51889 return NULL;
51890 }
51891
51892
51893 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51894 PyObject *obj;
51895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51896 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
51897 return SWIG_Py_Void();
51898 }
51899
51900 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51901 PyObject *resultobj = 0;
51902 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51903 wxIndividualLayoutConstraint *result = 0 ;
51904 void *argp1 = 0 ;
51905 int res1 = 0 ;
51906 PyObject *swig_obj[1] ;
51907
51908 if (!args) SWIG_fail;
51909 swig_obj[0] = args;
51910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51911 if (!SWIG_IsOK(res1)) {
51912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51913 }
51914 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51915 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
51916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51917 return resultobj;
51918 fail:
51919 return NULL;
51920 }
51921
51922
51923 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51924 PyObject *resultobj = 0;
51925 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51926 wxIndividualLayoutConstraint *result = 0 ;
51927 void *argp1 = 0 ;
51928 int res1 = 0 ;
51929 PyObject *swig_obj[1] ;
51930
51931 if (!args) SWIG_fail;
51932 swig_obj[0] = args;
51933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51934 if (!SWIG_IsOK(res1)) {
51935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51936 }
51937 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51938 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
51939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51940 return resultobj;
51941 fail:
51942 return NULL;
51943 }
51944
51945
51946 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51947 PyObject *resultobj = 0;
51948 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51949 wxIndividualLayoutConstraint *result = 0 ;
51950 void *argp1 = 0 ;
51951 int res1 = 0 ;
51952 PyObject *swig_obj[1] ;
51953
51954 if (!args) SWIG_fail;
51955 swig_obj[0] = args;
51956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51957 if (!SWIG_IsOK(res1)) {
51958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51959 }
51960 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51961 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
51962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51963 return resultobj;
51964 fail:
51965 return NULL;
51966 }
51967
51968
51969 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51970 PyObject *resultobj = 0;
51971 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51972 wxIndividualLayoutConstraint *result = 0 ;
51973 void *argp1 = 0 ;
51974 int res1 = 0 ;
51975 PyObject *swig_obj[1] ;
51976
51977 if (!args) SWIG_fail;
51978 swig_obj[0] = args;
51979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51980 if (!SWIG_IsOK(res1)) {
51981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51982 }
51983 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51984 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
51985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51986 return resultobj;
51987 fail:
51988 return NULL;
51989 }
51990
51991
51992 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51993 PyObject *resultobj = 0;
51994 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51995 wxIndividualLayoutConstraint *result = 0 ;
51996 void *argp1 = 0 ;
51997 int res1 = 0 ;
51998 PyObject *swig_obj[1] ;
51999
52000 if (!args) SWIG_fail;
52001 swig_obj[0] = args;
52002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52003 if (!SWIG_IsOK(res1)) {
52004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52005 }
52006 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52007 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52009 return resultobj;
52010 fail:
52011 return NULL;
52012 }
52013
52014
52015 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52016 PyObject *resultobj = 0;
52017 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52018 wxIndividualLayoutConstraint *result = 0 ;
52019 void *argp1 = 0 ;
52020 int res1 = 0 ;
52021 PyObject *swig_obj[1] ;
52022
52023 if (!args) SWIG_fail;
52024 swig_obj[0] = args;
52025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52028 }
52029 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52030 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52032 return resultobj;
52033 fail:
52034 return NULL;
52035 }
52036
52037
52038 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52039 PyObject *resultobj = 0;
52040 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52041 wxIndividualLayoutConstraint *result = 0 ;
52042 void *argp1 = 0 ;
52043 int res1 = 0 ;
52044 PyObject *swig_obj[1] ;
52045
52046 if (!args) SWIG_fail;
52047 swig_obj[0] = args;
52048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52049 if (!SWIG_IsOK(res1)) {
52050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52051 }
52052 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52053 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52055 return resultobj;
52056 fail:
52057 return NULL;
52058 }
52059
52060
52061 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52062 PyObject *resultobj = 0;
52063 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52064 wxIndividualLayoutConstraint *result = 0 ;
52065 void *argp1 = 0 ;
52066 int res1 = 0 ;
52067 PyObject *swig_obj[1] ;
52068
52069 if (!args) SWIG_fail;
52070 swig_obj[0] = args;
52071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52072 if (!SWIG_IsOK(res1)) {
52073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52074 }
52075 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52076 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52078 return resultobj;
52079 fail:
52080 return NULL;
52081 }
52082
52083
52084 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52085 PyObject *resultobj = 0;
52086 wxLayoutConstraints *result = 0 ;
52087
52088 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52089 {
52090 PyThreadState* __tstate = wxPyBeginAllowThreads();
52091 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52092 wxPyEndAllowThreads(__tstate);
52093 if (PyErr_Occurred()) SWIG_fail;
52094 }
52095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52096 return resultobj;
52097 fail:
52098 return NULL;
52099 }
52100
52101
52102 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52103 PyObject *resultobj = 0;
52104 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52105 void *argp1 = 0 ;
52106 int res1 = 0 ;
52107 PyObject *swig_obj[1] ;
52108
52109 if (!args) SWIG_fail;
52110 swig_obj[0] = args;
52111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52112 if (!SWIG_IsOK(res1)) {
52113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52114 }
52115 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52116 {
52117 PyThreadState* __tstate = wxPyBeginAllowThreads();
52118 delete arg1;
52119
52120 wxPyEndAllowThreads(__tstate);
52121 if (PyErr_Occurred()) SWIG_fail;
52122 }
52123 resultobj = SWIG_Py_Void();
52124 return resultobj;
52125 fail:
52126 return NULL;
52127 }
52128
52129
52130 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52131 PyObject *resultobj = 0;
52132 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52133 wxWindow *arg2 = (wxWindow *) 0 ;
52134 int *arg3 = (int *) 0 ;
52135 bool result;
52136 void *argp1 = 0 ;
52137 int res1 = 0 ;
52138 void *argp2 = 0 ;
52139 int res2 = 0 ;
52140 int temp3 ;
52141 int res3 = SWIG_TMPOBJ ;
52142 PyObject * obj0 = 0 ;
52143 PyObject * obj1 = 0 ;
52144 char * kwnames[] = {
52145 (char *) "self",(char *) "win", NULL
52146 };
52147
52148 arg3 = &temp3;
52149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52151 if (!SWIG_IsOK(res1)) {
52152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52153 }
52154 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52156 if (!SWIG_IsOK(res2)) {
52157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52158 }
52159 arg2 = reinterpret_cast< wxWindow * >(argp2);
52160 {
52161 PyThreadState* __tstate = wxPyBeginAllowThreads();
52162 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52163 wxPyEndAllowThreads(__tstate);
52164 if (PyErr_Occurred()) SWIG_fail;
52165 }
52166 {
52167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52168 }
52169 if (SWIG_IsTmpObj(res3)) {
52170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52171 } else {
52172 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52174 }
52175 return resultobj;
52176 fail:
52177 return NULL;
52178 }
52179
52180
52181 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52182 PyObject *resultobj = 0;
52183 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52184 bool result;
52185 void *argp1 = 0 ;
52186 int res1 = 0 ;
52187 PyObject *swig_obj[1] ;
52188
52189 if (!args) SWIG_fail;
52190 swig_obj[0] = args;
52191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52192 if (!SWIG_IsOK(res1)) {
52193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52194 }
52195 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52196 {
52197 PyThreadState* __tstate = wxPyBeginAllowThreads();
52198 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52199 wxPyEndAllowThreads(__tstate);
52200 if (PyErr_Occurred()) SWIG_fail;
52201 }
52202 {
52203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52204 }
52205 return resultobj;
52206 fail:
52207 return NULL;
52208 }
52209
52210
52211 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52212 PyObject *obj;
52213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52214 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52215 return SWIG_Py_Void();
52216 }
52217
52218 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52219 return SWIG_Python_InitShadowInstance(args);
52220 }
52221
52222 static PyMethodDef SwigMethods[] = {
52223 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52224 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52225 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52226 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52227 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52228 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52229 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52230 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52231 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52232 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52233 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52234 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52235 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52236 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52237 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52238 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52239 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52240 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52241 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52242 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52243 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52244 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52245 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52246 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52247 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52248 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52249 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52250 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52251 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52252 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52253 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52254 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52255 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52256 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52257 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52258 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52259 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52260 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52261 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52262 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52263 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52264 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52265 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52266 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52267 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52268 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52269 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52270 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52271 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52272 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52273 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52274 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52275 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52276 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52277 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52278 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52279 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52280 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52281 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52282 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52283 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52284 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52285 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52286 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52287 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52288 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52289 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52290 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52291 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52292 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52293 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52294 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52295 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52296 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52297 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52298 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52299 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52300 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52301 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52302 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52303 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52304 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52305 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52306 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52307 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52308 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52309 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52310 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52311 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52312 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52313 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52314 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52315 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52316 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52317 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52318 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52319 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52320 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52321 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52322 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52323 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52324 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52325 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52326 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52327 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52328 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52329 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52330 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52331 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52332 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52333 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52334 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52335 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52336 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52337 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52338 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52339 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52340 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52341 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52342 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52343 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52344 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52345 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52346 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52347 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52348 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52349 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52350 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52351 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52352 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52353 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52354 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52355 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52356 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52357 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52358 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52359 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52360 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52361 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52362 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52363 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52364 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52365 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52366 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52367 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52368 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52369 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52370 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52371 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52372 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52373 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52374 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52375 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52376 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52377 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52378 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52379 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52380 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52381 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52382 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52383 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52384 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52385 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52386 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52387 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52388 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52389 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52390 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52391 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52392 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52393 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52394 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52395 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52396 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52397 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52398 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52399 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52401 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52403 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52404 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52406 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52407 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52408 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52409 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52410 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52411 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52412 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52413 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52415 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52417 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52418 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52419 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52420 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52421 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52422 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52423 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52424 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52425 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52427 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52428 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52429 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52430 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52432 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52433 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52434 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52435 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52436 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52437 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52440 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52441 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52445 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52446 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52447 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52448 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52449 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52450 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52451 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52456 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52457 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52458 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52459 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52460 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52461 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52462 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52463 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52464 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52465 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52468 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52469 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52470 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52471 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52472 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52473 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52474 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52475 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52476 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52477 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52478 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52480 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52481 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52482 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52483 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52484 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52485 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52486 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52487 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52489 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52496 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52497 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52498 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52499 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52500 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52501 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52502 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52510 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52511 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52516 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52526 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52527 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52528 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52529 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52532 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52534 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52536 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52538 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52540 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52543 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52544 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52545 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52546 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52548 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52550 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52552 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52565 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52566 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52572 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52573 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52574 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52575 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52576 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52577 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52578 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52579 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52580 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52581 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52582 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52583 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52584 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52585 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52586 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52587 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52588 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52589 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52590 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52591 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52592 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52593 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52594 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52595 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52596 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52597 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52598 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52599 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52600 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52601 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52602 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52603 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52604 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52605 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52606 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52607 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52608 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52609 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52610 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52611 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52614 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52618 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52622 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52623 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52624 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52625 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52627 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52628 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52630 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52632 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52634 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52636 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52637 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52638 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52640 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52641 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52643 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52644 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52645 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52647 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52648 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52649 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52651 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52653 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52654 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52655 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52657 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52659 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52660 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52662 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52663 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52664 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52666 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52667 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52668 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52669 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52670 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52672 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52673 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52676 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52677 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52679 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52680 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52683 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52684 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52686 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52692 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52693 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52694 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52695 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52696 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52697 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52698 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52699 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52700 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52701 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52702 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52703 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52704 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52705 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52706 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52707 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52708 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52709 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52710 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52711 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52712 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52713 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52714 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52715 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52717 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52718 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52719 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52720 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52721 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52722 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52723 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52724 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52725 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52726 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52727 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52728 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52729 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52730 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52731 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52732 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52733 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52734 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52735 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52736 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52737 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52738 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52739 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52740 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52741 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52742 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52743 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52744 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52745 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52746 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52747 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52748 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52750 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52751 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52753 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52754 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52755 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52756 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52758 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52759 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52760 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52761 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52762 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52763 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52764 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52765 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52766 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52767 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52768 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52769 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52770 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52771 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52772 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52773 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52774 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52775 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52776 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52777 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52778 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52779 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52780 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52781 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52782 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52783 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52784 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52785 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52786 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52787 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52788 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52789 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52790 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52791 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52792 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52793 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52794 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52796 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52797 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52800 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52801 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52802 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52803 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52804 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52805 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52807 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52808 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52811 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52812 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52814 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52815 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52817 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52818 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52820 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52821 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52822 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52824 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52826 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52827 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52829 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52830 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52831 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52833 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52834 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52835 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52837 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52838 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52840 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52841 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52842 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52843 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52844 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52847 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52849 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52851 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52852 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52853 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52856 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52857 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52858 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52860 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52861 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52862 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52864 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52865 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52866 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52867 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52868 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52869 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
52871 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
52872 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
52873 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
52874 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
52875 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
52876 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
52877 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
52878 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
52884 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
52886 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
52888 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
52889 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
52890 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
52891 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
52892 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
52893 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
52895 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
52896 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
52897 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
52898 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
52899 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
52900 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
52903 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
52904 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
52905 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
52908 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
52909 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
52910 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
52911 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
52912 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
52914 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
52916 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
52919 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
52921 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
52922 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
52924 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
52925 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
52926 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
52928 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
52929 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
52930 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
52932 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
52934 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
52935 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
52936 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
52938 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
52940 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
52942 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
52943 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
52945 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
52947 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
52948 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
52949 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
52951 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
52953 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
52954 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
52955 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
52957 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
52959 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
52960 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
52961 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
52962 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
52964 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
52966 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
52968 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
52970 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
52971 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
52973 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
52974 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
52975 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
52976 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
52977 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
52978 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
52979 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
52980 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
52982 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
52984 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
52986 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
52988 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
52990 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
52992 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
52993 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
52994 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
52995 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
52996 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
52997 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53003 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53004 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53005 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53006 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53007 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53008 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53009 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53011 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53013 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53014 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53016 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53017 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53018 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53019 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53021 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53022 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53023 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53024 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53026 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53027 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53029 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53030 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53031 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53033 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53035 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53036 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53037 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53038 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53039 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53041 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53042 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53043 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53044 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53046 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53047 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53048 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53049 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53050 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53051 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53052 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53053 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53054 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53055 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53057 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53060 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53061 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53062 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53064 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53066 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53068 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53070 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53071 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53081 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53082 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53086 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53087 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53088 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53089 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53090 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53091 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53092 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53093 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53094 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53095 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53096 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53097 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53099 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53100 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53103 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53104 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53109 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53110 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53113 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53114 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53115 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53116 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53119 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53120 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53121 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53123 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53125 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53126 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53127 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53129 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53131 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53133 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53136 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53137 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53138 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53139 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53140 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53141 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53142 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53148 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53149 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53150 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53151 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53157 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53163 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53164 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53165 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53166 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53167 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53169 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53179 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53180 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53181 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53182 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53185 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53186 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53187 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53188 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53190 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53191 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53195 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53201 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53202 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53203 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53204 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53206 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53207 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53209 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53212 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53214 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53215 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53216 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53225 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53229 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53231 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53241 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53242 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53243 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53244 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53247 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53250 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53252 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53255 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53257 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53258 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53261 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53263 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53264 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53265 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53266 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53267 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53272 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53273 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53274 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53276 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53277 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53278 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53280 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53282 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53283 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53284 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53286 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53287 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53290 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53297 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53304 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53312 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53315 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53316 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53329 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53331 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53333 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53334 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53336 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53338 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53339 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53341 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53342 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53343 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53347 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53366 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53367 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53369 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53371 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53372 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53373 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53375 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53376 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53379 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53380 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53382 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53383 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53385 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53388 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53389 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53391 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53393 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53395 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53396 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53398 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53399 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53402 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53404 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53406 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53408 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53411 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53413 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53414 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53415 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53417 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53418 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53421 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53424 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53426 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53427 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53431 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53435 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53436 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53438 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53442 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53444 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53446 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53447 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53448 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53449 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53453 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53454 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53455 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53456 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53458 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53459 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53464 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53465 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53466 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53467 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53468 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53470 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53472 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53474 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53475 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53477 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53479 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53482 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53483 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53484 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53486 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53487 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53488 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53502 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53503 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53504 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53505 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53506 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53507 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53513 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53514 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53518 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53519 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53521 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53522 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53524 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53526 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53527 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53529 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53530 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53531 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53537 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53538 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53539 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53540 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53541 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53542 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53549 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53551 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53552 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53553 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53554 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53555 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53556 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53558 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53562 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53563 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53564 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53565 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53566 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53567 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53568 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53570 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53571 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53572 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53578 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53579 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53580 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53582 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53583 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53584 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53590 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53591 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53592 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53593 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53594 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53598 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53599 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53604 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53605 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53607 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53608 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53613 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53615 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53616 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53617 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53618 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53619 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53624 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53625 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53634 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53635 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53636 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53637 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53640 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53642 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53643 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53644 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53645 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53647 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53652 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53653 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53654 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53655 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53656 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53657 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53658 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53659 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53660 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53661 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53662 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53664 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53665 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53666 { NULL, NULL, 0, NULL }
53667 };
53668
53669
53670 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53671
53672 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53673 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53674 }
53675 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53676 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53677 }
53678 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53679 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53680 }
53681 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53682 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53683 }
53684 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53685 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53686 }
53687 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53688 return (void *)((wxSizer *) ((wxGridSizer *) x));
53689 }
53690 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53691 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53692 }
53693 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53694 return (void *)((wxSizer *) ((wxPySizer *) x));
53695 }
53696 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53697 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53698 }
53699 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53700 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53701 }
53702 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53703 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53704 }
53705 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53706 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53707 }
53708 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53709 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53710 }
53711 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53712 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53713 }
53714 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53715 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53716 }
53717 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53718 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53719 }
53720 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53721 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53722 }
53723 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53724 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53725 }
53726 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53727 return (void *)((wxEvent *) ((wxPyEvent *) x));
53728 }
53729 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53731 }
53732 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53733 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53734 }
53735 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53737 }
53738 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53739 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53740 }
53741 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53742 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53743 }
53744 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53745 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53746 }
53747 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53748 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53749 }
53750 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53751 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53752 }
53753 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53754 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53755 }
53756 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53757 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53758 }
53759 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53760 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53761 }
53762 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53763 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53764 }
53765 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53767 }
53768 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53769 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53770 }
53771 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53772 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53773 }
53774 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53775 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53776 }
53777 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53778 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53779 }
53780 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53781 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53782 }
53783 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53784 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53785 }
53786 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53787 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53788 }
53789 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53790 return (void *)((wxEvent *) ((wxShowEvent *) x));
53791 }
53792 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53793 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53794 }
53795 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53796 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53797 }
53798 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53799 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53800 }
53801 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53802 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53803 }
53804 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53805 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53806 }
53807 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53808 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53809 }
53810 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53811 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53812 }
53813 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53814 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53815 }
53816 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53817 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53818 }
53819 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53820 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53821 }
53822 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53823 return (void *)((wxControl *) ((wxControlWithItems *) x));
53824 }
53825 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53826 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53827 }
53828 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53829 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53830 }
53831 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53832 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53833 }
53834 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53835 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53836 }
53837 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53838 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53839 }
53840 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53841 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53842 }
53843 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53844 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53845 }
53846 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53847 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53848 }
53849 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53850 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53851 }
53852 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53853 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53854 }
53855 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53856 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53857 }
53858 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53859 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53860 }
53861 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53862 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53863 }
53864 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53865 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53866 }
53867 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
53868 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
53869 }
53870 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
53871 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
53872 }
53873 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
53874 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
53875 }
53876 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
53877 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
53878 }
53879 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
53880 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53881 }
53882 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
53883 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
53884 }
53885 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
53886 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
53887 }
53888 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
53889 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
53890 }
53891 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
53892 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
53893 }
53894 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
53895 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
53896 }
53897 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
53898 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
53899 }
53900 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
53901 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
53902 }
53903 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
53904 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
53905 }
53906 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
53907 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
53908 }
53909 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
53910 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
53911 }
53912 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
53913 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
53914 }
53915 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
53916 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
53917 }
53918 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
53919 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
53920 }
53921 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
53922 return (void *)((wxObject *) ((wxSizerItem *) x));
53923 }
53924 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
53925 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
53926 }
53927 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
53928 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
53929 }
53930 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
53931 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
53932 }
53933 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
53934 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
53935 }
53936 static void *_p_wxSizerTo_p_wxObject(void *x) {
53937 return (void *)((wxObject *) ((wxSizer *) x));
53938 }
53939 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
53940 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53941 }
53942 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
53943 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
53944 }
53945 static void *_p_wxEventTo_p_wxObject(void *x) {
53946 return (void *)((wxObject *) ((wxEvent *) x));
53947 }
53948 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
53949 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
53950 }
53951 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
53952 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
53953 }
53954 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
53955 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
53956 }
53957 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
53958 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
53959 }
53960 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
53961 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
53962 }
53963 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
53964 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
53965 }
53966 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
53967 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
53968 }
53969 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
53970 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53971 }
53972 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
53973 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
53974 }
53975 static void *_p_wxControlTo_p_wxObject(void *x) {
53976 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
53977 }
53978 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
53979 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
53980 }
53981 static void *_p_wxFSFileTo_p_wxObject(void *x) {
53982 return (void *)((wxObject *) ((wxFSFile *) x));
53983 }
53984 static void *_p_wxPySizerTo_p_wxObject(void *x) {
53985 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
53986 }
53987 static void *_p_wxPyEventTo_p_wxObject(void *x) {
53988 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
53989 }
53990 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
53991 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
53992 }
53993 static void *_p_wxShowEventTo_p_wxObject(void *x) {
53994 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
53995 }
53996 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
53997 return (void *)((wxObject *) ((wxMenuItem *) x));
53998 }
53999 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54000 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54001 }
54002 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54003 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54004 }
54005 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54006 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54007 }
54008 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54009 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54010 }
54011 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54012 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54013 }
54014 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54015 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54016 }
54017 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54018 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54019 }
54020 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54021 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54022 }
54023 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54024 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54025 }
54026 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54027 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54028 }
54029 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54030 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54031 }
54032 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54033 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54034 }
54035 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54036 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54037 }
54038 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54039 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54040 }
54041 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54042 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54043 }
54044 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54045 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54046 }
54047 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54048 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54049 }
54050 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54051 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54052 }
54053 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54054 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54055 }
54056 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54057 return (void *)((wxObject *) ((wxImageHandler *) x));
54058 }
54059 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54060 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54061 }
54062 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54063 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54064 }
54065 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54066 return (void *)((wxObject *) ((wxEvtHandler *) x));
54067 }
54068 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54069 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54070 }
54071 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54072 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54073 }
54074 static void *_p_wxImageTo_p_wxObject(void *x) {
54075 return (void *)((wxObject *) ((wxImage *) x));
54076 }
54077 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54078 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54079 }
54080 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54081 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54082 }
54083 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54084 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54085 }
54086 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54087 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54088 }
54089 static void *_p_wxWindowTo_p_wxObject(void *x) {
54090 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54091 }
54092 static void *_p_wxMenuTo_p_wxObject(void *x) {
54093 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54094 }
54095 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54096 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54097 }
54098 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54099 return (void *)((wxObject *) ((wxFileSystem *) x));
54100 }
54101 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54102 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54103 }
54104 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54105 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54106 }
54107 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54108 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54109 }
54110 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54111 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54112 }
54113 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54114 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54115 }
54116 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54117 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54118 }
54119 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54120 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54121 }
54122 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54123 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54124 }
54125 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54126 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54127 }
54128 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54129 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54130 }
54131 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54132 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54133 }
54134 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54135 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54136 }
54137 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54138 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54139 }
54140 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54141 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54142 }
54143 static void *_p_wxControlTo_p_wxWindow(void *x) {
54144 return (void *)((wxWindow *) ((wxControl *) x));
54145 }
54146 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54147 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54148 }
54149 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54150 return (void *)((wxWindow *) ((wxMenuBar *) x));
54151 }
54152 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54153 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54154 }
54155 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54156 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54157 }
54158 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54159 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54160 }
54161 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54162 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54163 }
54164 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54165 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54166 }
54167 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54168 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54169 }
54170 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54171 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54172 }
54173 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54174 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54175 }
54176 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54177 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54178 }
54179 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54180 return (void *)((wxValidator *) ((wxPyValidator *) x));
54181 }
54182 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54183 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54184 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};
54185 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54186 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54187 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54188 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54189 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54190 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54191 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54192 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54193 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54194 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54195 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54196 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54197 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54198 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54199 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54200 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54201 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54202 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54203 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54204 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54205 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54206 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54207 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54208 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54209 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54210 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54211 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54212 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54213 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54214 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54215 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54216 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54217 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54218 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54219 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54220 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54221 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54222 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54223 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54224 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54225 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54226 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54227 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54228 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54229 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54230 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54231 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54232 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54233 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54234 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54235 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54236 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54237 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54238 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54239 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54240 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54241 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54242 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54243 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54244 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54245 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54246 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54247 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54248 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54249 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54250 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54251 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54252 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54253 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54254 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54255 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54256 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54257 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54258 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54259 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54260 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54261 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54262 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54263 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54264 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54265 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54266 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54267 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54268 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54269 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54270 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54271 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54272 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54273 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54274 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54275 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54276 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54277 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54278 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54279 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54280 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54281 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54282 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54283 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54284 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54285 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54286 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54287 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54288 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54289 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54290 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54291 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54292 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54293 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54294 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54295 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54296 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54297 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54298 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54299 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54300 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54301 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54302 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54303 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54304 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54305 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54306 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54307 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54308 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54309 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54310 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54311
54312 static swig_type_info *swig_type_initial[] = {
54313 &_swigt__p_buffer,
54314 &_swigt__p_char,
54315 &_swigt__p_form_ops_t,
54316 &_swigt__p_int,
54317 &_swigt__p_long,
54318 &_swigt__p_unsigned_char,
54319 &_swigt__p_unsigned_int,
54320 &_swigt__p_unsigned_long,
54321 &_swigt__p_wxANIHandler,
54322 &_swigt__p_wxAcceleratorEntry,
54323 &_swigt__p_wxAcceleratorTable,
54324 &_swigt__p_wxActivateEvent,
54325 &_swigt__p_wxAppTraits,
54326 &_swigt__p_wxArrayString,
54327 &_swigt__p_wxBMPHandler,
54328 &_swigt__p_wxBitmap,
54329 &_swigt__p_wxBoxSizer,
54330 &_swigt__p_wxButton,
54331 &_swigt__p_wxCURHandler,
54332 &_swigt__p_wxCaret,
54333 &_swigt__p_wxChildFocusEvent,
54334 &_swigt__p_wxCloseEvent,
54335 &_swigt__p_wxColour,
54336 &_swigt__p_wxCommandEvent,
54337 &_swigt__p_wxContextMenuEvent,
54338 &_swigt__p_wxControl,
54339 &_swigt__p_wxControlWithItems,
54340 &_swigt__p_wxCursor,
54341 &_swigt__p_wxDC,
54342 &_swigt__p_wxDateEvent,
54343 &_swigt__p_wxDateTime,
54344 &_swigt__p_wxDisplayChangedEvent,
54345 &_swigt__p_wxDropFilesEvent,
54346 &_swigt__p_wxDuplexMode,
54347 &_swigt__p_wxEraseEvent,
54348 &_swigt__p_wxEvent,
54349 &_swigt__p_wxEventLoop,
54350 &_swigt__p_wxEventLoopActivator,
54351 &_swigt__p_wxEvtHandler,
54352 &_swigt__p_wxFSFile,
54353 &_swigt__p_wxFileSystem,
54354 &_swigt__p_wxFileSystemHandler,
54355 &_swigt__p_wxFlexGridSizer,
54356 &_swigt__p_wxFocusEvent,
54357 &_swigt__p_wxFont,
54358 &_swigt__p_wxFrame,
54359 &_swigt__p_wxGBPosition,
54360 &_swigt__p_wxGBSizerItem,
54361 &_swigt__p_wxGBSpan,
54362 &_swigt__p_wxGIFHandler,
54363 &_swigt__p_wxGridBagSizer,
54364 &_swigt__p_wxGridSizer,
54365 &_swigt__p_wxICOHandler,
54366 &_swigt__p_wxIconizeEvent,
54367 &_swigt__p_wxIdleEvent,
54368 &_swigt__p_wxImage,
54369 &_swigt__p_wxImageHandler,
54370 &_swigt__p_wxImageHistogram,
54371 &_swigt__p_wxImage_HSVValue,
54372 &_swigt__p_wxImage_RGBValue,
54373 &_swigt__p_wxIndividualLayoutConstraint,
54374 &_swigt__p_wxInitDialogEvent,
54375 &_swigt__p_wxInputStream,
54376 &_swigt__p_wxInternetFSHandler,
54377 &_swigt__p_wxItemContainer,
54378 &_swigt__p_wxJPEGHandler,
54379 &_swigt__p_wxKeyEvent,
54380 &_swigt__p_wxLayoutConstraints,
54381 &_swigt__p_wxMaximizeEvent,
54382 &_swigt__p_wxMemoryFSHandler,
54383 &_swigt__p_wxMenu,
54384 &_swigt__p_wxMenuBar,
54385 &_swigt__p_wxMenuBarBase,
54386 &_swigt__p_wxMenuEvent,
54387 &_swigt__p_wxMenuItem,
54388 &_swigt__p_wxMouseCaptureChangedEvent,
54389 &_swigt__p_wxMouseEvent,
54390 &_swigt__p_wxMoveEvent,
54391 &_swigt__p_wxNavigationKeyEvent,
54392 &_swigt__p_wxNcPaintEvent,
54393 &_swigt__p_wxNotifyEvent,
54394 &_swigt__p_wxObject,
54395 &_swigt__p_wxOutputStream,
54396 &_swigt__p_wxPCXHandler,
54397 &_swigt__p_wxPNGHandler,
54398 &_swigt__p_wxPNMHandler,
54399 &_swigt__p_wxPaintEvent,
54400 &_swigt__p_wxPaletteChangedEvent,
54401 &_swigt__p_wxPaperSize,
54402 &_swigt__p_wxPoint,
54403 &_swigt__p_wxPoint2D,
54404 &_swigt__p_wxPropagateOnce,
54405 &_swigt__p_wxPropagationDisabler,
54406 &_swigt__p_wxPyApp,
54407 &_swigt__p_wxPyCommandEvent,
54408 &_swigt__p_wxPyDropTarget,
54409 &_swigt__p_wxPyEvent,
54410 &_swigt__p_wxPyFileSystemHandler,
54411 &_swigt__p_wxPyImageHandler,
54412 &_swigt__p_wxPyInputStream,
54413 &_swigt__p_wxPySizer,
54414 &_swigt__p_wxPyValidator,
54415 &_swigt__p_wxQuantize,
54416 &_swigt__p_wxQueryNewPaletteEvent,
54417 &_swigt__p_wxRealPoint,
54418 &_swigt__p_wxRect,
54419 &_swigt__p_wxRegion,
54420 &_swigt__p_wxScrollEvent,
54421 &_swigt__p_wxScrollWinEvent,
54422 &_swigt__p_wxSetCursorEvent,
54423 &_swigt__p_wxShowEvent,
54424 &_swigt__p_wxSize,
54425 &_swigt__p_wxSizeEvent,
54426 &_swigt__p_wxSizer,
54427 &_swigt__p_wxSizerItem,
54428 &_swigt__p_wxStaticBox,
54429 &_swigt__p_wxStaticBoxSizer,
54430 &_swigt__p_wxStdDialogButtonSizer,
54431 &_swigt__p_wxSysColourChangedEvent,
54432 &_swigt__p_wxTIFFHandler,
54433 &_swigt__p_wxToolTip,
54434 &_swigt__p_wxUpdateUIEvent,
54435 &_swigt__p_wxValidator,
54436 &_swigt__p_wxVisualAttributes,
54437 &_swigt__p_wxWindow,
54438 &_swigt__p_wxWindowCreateEvent,
54439 &_swigt__p_wxWindowDestroyEvent,
54440 &_swigt__p_wxXPMHandler,
54441 &_swigt__p_wxZipFSHandler,
54442 };
54443
54444 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54445 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54446 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54447 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54448 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54449 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54450 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54451 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54452 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54453 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54454 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54455 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54456 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54457 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54458 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}};
54459 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54460 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}};
54461 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54462 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}};
54463 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54464 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54465 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54466 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54467 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}};
54468 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54469 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}};
54470 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54471 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54472 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54473 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54474 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54475 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54476 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54477 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54478 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54479 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}};
54480 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54481 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54482 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}};
54483 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54484 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54485 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}};
54486 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}};
54487 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54488 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54489 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54490 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54491 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54492 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54493 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54494 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54495 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}};
54496 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}};
54497 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54498 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54499 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54500 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}};
54501 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54502 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54503 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54504 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54505 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54506 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54507 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54508 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}};
54509 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54510 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54511 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54512 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54513 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54514 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54515 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54516 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54517 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54518 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54519 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54520 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54521 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54522 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54523 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54524 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54525 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}};
54526 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54527 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54528 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54529 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54530 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54531 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54532 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54533 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54534 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54535 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54536 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54537 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54538 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54539 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54540 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54541 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54542 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54543 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54544 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54545 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54546 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54547 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54548 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54549 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54550 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54551 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54552 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54553 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54554 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54555 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54556 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54557 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}};
54558 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}};
54559 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54560 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54561 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54562 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54563 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54564 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54565 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54566 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}};
54567 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54568 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}};
54569 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54570 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54571 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54572 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54573
54574 static swig_cast_info *swig_cast_initial[] = {
54575 _swigc__p_buffer,
54576 _swigc__p_char,
54577 _swigc__p_form_ops_t,
54578 _swigc__p_int,
54579 _swigc__p_long,
54580 _swigc__p_unsigned_char,
54581 _swigc__p_unsigned_int,
54582 _swigc__p_unsigned_long,
54583 _swigc__p_wxANIHandler,
54584 _swigc__p_wxAcceleratorEntry,
54585 _swigc__p_wxAcceleratorTable,
54586 _swigc__p_wxActivateEvent,
54587 _swigc__p_wxAppTraits,
54588 _swigc__p_wxArrayString,
54589 _swigc__p_wxBMPHandler,
54590 _swigc__p_wxBitmap,
54591 _swigc__p_wxBoxSizer,
54592 _swigc__p_wxButton,
54593 _swigc__p_wxCURHandler,
54594 _swigc__p_wxCaret,
54595 _swigc__p_wxChildFocusEvent,
54596 _swigc__p_wxCloseEvent,
54597 _swigc__p_wxColour,
54598 _swigc__p_wxCommandEvent,
54599 _swigc__p_wxContextMenuEvent,
54600 _swigc__p_wxControl,
54601 _swigc__p_wxControlWithItems,
54602 _swigc__p_wxCursor,
54603 _swigc__p_wxDC,
54604 _swigc__p_wxDateEvent,
54605 _swigc__p_wxDateTime,
54606 _swigc__p_wxDisplayChangedEvent,
54607 _swigc__p_wxDropFilesEvent,
54608 _swigc__p_wxDuplexMode,
54609 _swigc__p_wxEraseEvent,
54610 _swigc__p_wxEvent,
54611 _swigc__p_wxEventLoop,
54612 _swigc__p_wxEventLoopActivator,
54613 _swigc__p_wxEvtHandler,
54614 _swigc__p_wxFSFile,
54615 _swigc__p_wxFileSystem,
54616 _swigc__p_wxFileSystemHandler,
54617 _swigc__p_wxFlexGridSizer,
54618 _swigc__p_wxFocusEvent,
54619 _swigc__p_wxFont,
54620 _swigc__p_wxFrame,
54621 _swigc__p_wxGBPosition,
54622 _swigc__p_wxGBSizerItem,
54623 _swigc__p_wxGBSpan,
54624 _swigc__p_wxGIFHandler,
54625 _swigc__p_wxGridBagSizer,
54626 _swigc__p_wxGridSizer,
54627 _swigc__p_wxICOHandler,
54628 _swigc__p_wxIconizeEvent,
54629 _swigc__p_wxIdleEvent,
54630 _swigc__p_wxImage,
54631 _swigc__p_wxImageHandler,
54632 _swigc__p_wxImageHistogram,
54633 _swigc__p_wxImage_HSVValue,
54634 _swigc__p_wxImage_RGBValue,
54635 _swigc__p_wxIndividualLayoutConstraint,
54636 _swigc__p_wxInitDialogEvent,
54637 _swigc__p_wxInputStream,
54638 _swigc__p_wxInternetFSHandler,
54639 _swigc__p_wxItemContainer,
54640 _swigc__p_wxJPEGHandler,
54641 _swigc__p_wxKeyEvent,
54642 _swigc__p_wxLayoutConstraints,
54643 _swigc__p_wxMaximizeEvent,
54644 _swigc__p_wxMemoryFSHandler,
54645 _swigc__p_wxMenu,
54646 _swigc__p_wxMenuBar,
54647 _swigc__p_wxMenuBarBase,
54648 _swigc__p_wxMenuEvent,
54649 _swigc__p_wxMenuItem,
54650 _swigc__p_wxMouseCaptureChangedEvent,
54651 _swigc__p_wxMouseEvent,
54652 _swigc__p_wxMoveEvent,
54653 _swigc__p_wxNavigationKeyEvent,
54654 _swigc__p_wxNcPaintEvent,
54655 _swigc__p_wxNotifyEvent,
54656 _swigc__p_wxObject,
54657 _swigc__p_wxOutputStream,
54658 _swigc__p_wxPCXHandler,
54659 _swigc__p_wxPNGHandler,
54660 _swigc__p_wxPNMHandler,
54661 _swigc__p_wxPaintEvent,
54662 _swigc__p_wxPaletteChangedEvent,
54663 _swigc__p_wxPaperSize,
54664 _swigc__p_wxPoint,
54665 _swigc__p_wxPoint2D,
54666 _swigc__p_wxPropagateOnce,
54667 _swigc__p_wxPropagationDisabler,
54668 _swigc__p_wxPyApp,
54669 _swigc__p_wxPyCommandEvent,
54670 _swigc__p_wxPyDropTarget,
54671 _swigc__p_wxPyEvent,
54672 _swigc__p_wxPyFileSystemHandler,
54673 _swigc__p_wxPyImageHandler,
54674 _swigc__p_wxPyInputStream,
54675 _swigc__p_wxPySizer,
54676 _swigc__p_wxPyValidator,
54677 _swigc__p_wxQuantize,
54678 _swigc__p_wxQueryNewPaletteEvent,
54679 _swigc__p_wxRealPoint,
54680 _swigc__p_wxRect,
54681 _swigc__p_wxRegion,
54682 _swigc__p_wxScrollEvent,
54683 _swigc__p_wxScrollWinEvent,
54684 _swigc__p_wxSetCursorEvent,
54685 _swigc__p_wxShowEvent,
54686 _swigc__p_wxSize,
54687 _swigc__p_wxSizeEvent,
54688 _swigc__p_wxSizer,
54689 _swigc__p_wxSizerItem,
54690 _swigc__p_wxStaticBox,
54691 _swigc__p_wxStaticBoxSizer,
54692 _swigc__p_wxStdDialogButtonSizer,
54693 _swigc__p_wxSysColourChangedEvent,
54694 _swigc__p_wxTIFFHandler,
54695 _swigc__p_wxToolTip,
54696 _swigc__p_wxUpdateUIEvent,
54697 _swigc__p_wxValidator,
54698 _swigc__p_wxVisualAttributes,
54699 _swigc__p_wxWindow,
54700 _swigc__p_wxWindowCreateEvent,
54701 _swigc__p_wxWindowDestroyEvent,
54702 _swigc__p_wxXPMHandler,
54703 _swigc__p_wxZipFSHandler,
54704 };
54705
54706
54707 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54708
54709 static swig_const_info swig_const_table[] = {
54710 {0, 0, 0, 0.0, 0, 0}};
54711
54712 #ifdef __cplusplus
54713 }
54714 #endif
54715 /* -----------------------------------------------------------------------------
54716 * Type initialization:
54717 * This problem is tough by the requirement that no dynamic
54718 * memory is used. Also, since swig_type_info structures store pointers to
54719 * swig_cast_info structures and swig_cast_info structures store pointers back
54720 * to swig_type_info structures, we need some lookup code at initialization.
54721 * The idea is that swig generates all the structures that are needed.
54722 * The runtime then collects these partially filled structures.
54723 * The SWIG_InitializeModule function takes these initial arrays out of
54724 * swig_module, and does all the lookup, filling in the swig_module.types
54725 * array with the correct data and linking the correct swig_cast_info
54726 * structures together.
54727 *
54728 * The generated swig_type_info structures are assigned staticly to an initial
54729 * array. We just loop though that array, and handle each type individually.
54730 * First we lookup if this type has been already loaded, and if so, use the
54731 * loaded structure instead of the generated one. Then we have to fill in the
54732 * cast linked list. The cast data is initially stored in something like a
54733 * two-dimensional array. Each row corresponds to a type (there are the same
54734 * number of rows as there are in the swig_type_initial array). Each entry in
54735 * a column is one of the swig_cast_info structures for that type.
54736 * The cast_initial array is actually an array of arrays, because each row has
54737 * a variable number of columns. So to actually build the cast linked list,
54738 * we find the array of casts associated with the type, and loop through it
54739 * adding the casts to the list. The one last trick we need to do is making
54740 * sure the type pointer in the swig_cast_info struct is correct.
54741 *
54742 * First off, we lookup the cast->type name to see if it is already loaded.
54743 * There are three cases to handle:
54744 * 1) If the cast->type has already been loaded AND the type we are adding
54745 * casting info to has not been loaded (it is in this module), THEN we
54746 * replace the cast->type pointer with the type pointer that has already
54747 * been loaded.
54748 * 2) If BOTH types (the one we are adding casting info to, and the
54749 * cast->type) are loaded, THEN the cast info has already been loaded by
54750 * the previous module so we just ignore it.
54751 * 3) Finally, if cast->type has not already been loaded, then we add that
54752 * swig_cast_info to the linked list (because the cast->type) pointer will
54753 * be correct.
54754 * ----------------------------------------------------------------------------- */
54755
54756 #ifdef __cplusplus
54757 extern "C" {
54758 #if 0
54759 } /* c-mode */
54760 #endif
54761 #endif
54762
54763 #if 0
54764 #define SWIGRUNTIME_DEBUG
54765 #endif
54766
54767 SWIGRUNTIME void
54768 SWIG_InitializeModule(void *clientdata) {
54769 size_t i;
54770 swig_module_info *module_head;
54771 static int init_run = 0;
54772
54773 clientdata = clientdata;
54774
54775 if (init_run) return;
54776 init_run = 1;
54777
54778 /* Initialize the swig_module */
54779 swig_module.type_initial = swig_type_initial;
54780 swig_module.cast_initial = swig_cast_initial;
54781
54782 /* Try and load any already created modules */
54783 module_head = SWIG_GetModule(clientdata);
54784 if (module_head) {
54785 swig_module.next = module_head->next;
54786 module_head->next = &swig_module;
54787 } else {
54788 /* This is the first module loaded */
54789 swig_module.next = &swig_module;
54790 SWIG_SetModule(clientdata, &swig_module);
54791 }
54792
54793 /* Now work on filling in swig_module.types */
54794 #ifdef SWIGRUNTIME_DEBUG
54795 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54796 #endif
54797 for (i = 0; i < swig_module.size; ++i) {
54798 swig_type_info *type = 0;
54799 swig_type_info *ret;
54800 swig_cast_info *cast;
54801
54802 #ifdef SWIGRUNTIME_DEBUG
54803 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54804 #endif
54805
54806 /* if there is another module already loaded */
54807 if (swig_module.next != &swig_module) {
54808 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54809 }
54810 if (type) {
54811 /* Overwrite clientdata field */
54812 #ifdef SWIGRUNTIME_DEBUG
54813 printf("SWIG_InitializeModule: found type %s\n", type->name);
54814 #endif
54815 if (swig_module.type_initial[i]->clientdata) {
54816 type->clientdata = swig_module.type_initial[i]->clientdata;
54817 #ifdef SWIGRUNTIME_DEBUG
54818 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54819 #endif
54820 }
54821 } else {
54822 type = swig_module.type_initial[i];
54823 }
54824
54825 /* Insert casting types */
54826 cast = swig_module.cast_initial[i];
54827 while (cast->type) {
54828 /* Don't need to add information already in the list */
54829 ret = 0;
54830 #ifdef SWIGRUNTIME_DEBUG
54831 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54832 #endif
54833 if (swig_module.next != &swig_module) {
54834 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54835 #ifdef SWIGRUNTIME_DEBUG
54836 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54837 #endif
54838 }
54839 if (ret) {
54840 if (type == swig_module.type_initial[i]) {
54841 #ifdef SWIGRUNTIME_DEBUG
54842 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54843 #endif
54844 cast->type = ret;
54845 ret = 0;
54846 } else {
54847 /* Check for casting already in the list */
54848 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54849 #ifdef SWIGRUNTIME_DEBUG
54850 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54851 #endif
54852 if (!ocast) ret = 0;
54853 }
54854 }
54855
54856 if (!ret) {
54857 #ifdef SWIGRUNTIME_DEBUG
54858 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54859 #endif
54860 if (type->cast) {
54861 type->cast->prev = cast;
54862 cast->next = type->cast;
54863 }
54864 type->cast = cast;
54865 }
54866 cast++;
54867 }
54868 /* Set entry in modules->types array equal to the type */
54869 swig_module.types[i] = type;
54870 }
54871 swig_module.types[i] = 0;
54872
54873 #ifdef SWIGRUNTIME_DEBUG
54874 printf("**** SWIG_InitializeModule: Cast List ******\n");
54875 for (i = 0; i < swig_module.size; ++i) {
54876 int j = 0;
54877 swig_cast_info *cast = swig_module.cast_initial[i];
54878 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54879 while (cast->type) {
54880 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
54881 cast++;
54882 ++j;
54883 }
54884 printf("---- Total casts: %d\n",j);
54885 }
54886 printf("**** SWIG_InitializeModule: Cast List ******\n");
54887 #endif
54888 }
54889
54890 /* This function will propagate the clientdata field of type to
54891 * any new swig_type_info structures that have been added into the list
54892 * of equivalent types. It is like calling
54893 * SWIG_TypeClientData(type, clientdata) a second time.
54894 */
54895 SWIGRUNTIME void
54896 SWIG_PropagateClientData(void) {
54897 size_t i;
54898 swig_cast_info *equiv;
54899 static int init_run = 0;
54900
54901 if (init_run) return;
54902 init_run = 1;
54903
54904 for (i = 0; i < swig_module.size; i++) {
54905 if (swig_module.types[i]->clientdata) {
54906 equiv = swig_module.types[i]->cast;
54907 while (equiv) {
54908 if (!equiv->converter) {
54909 if (equiv->type && !equiv->type->clientdata)
54910 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
54911 }
54912 equiv = equiv->next;
54913 }
54914 }
54915 }
54916 }
54917
54918 #ifdef __cplusplus
54919 #if 0
54920 {
54921 /* c-mode */
54922 #endif
54923 }
54924 #endif
54925
54926
54927
54928 #ifdef __cplusplus
54929 extern "C" {
54930 #endif
54931
54932 /* Python-specific SWIG API */
54933 #define SWIG_newvarlink() SWIG_Python_newvarlink()
54934 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
54935 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
54936
54937 /* -----------------------------------------------------------------------------
54938 * global variable support code.
54939 * ----------------------------------------------------------------------------- */
54940
54941 typedef struct swig_globalvar {
54942 char *name; /* Name of global variable */
54943 PyObject *(*get_attr)(void); /* Return the current value */
54944 int (*set_attr)(PyObject *); /* Set the value */
54945 struct swig_globalvar *next;
54946 } swig_globalvar;
54947
54948 typedef struct swig_varlinkobject {
54949 PyObject_HEAD
54950 swig_globalvar *vars;
54951 } swig_varlinkobject;
54952
54953 SWIGINTERN PyObject *
54954 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
54955 return PyString_FromString("<Swig global variables>");
54956 }
54957
54958 SWIGINTERN PyObject *
54959 swig_varlink_str(swig_varlinkobject *v) {
54960 PyObject *str = PyString_FromString("(");
54961 swig_globalvar *var;
54962 for (var = v->vars; var; var=var->next) {
54963 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
54964 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
54965 }
54966 PyString_ConcatAndDel(&str,PyString_FromString(")"));
54967 return str;
54968 }
54969
54970 SWIGINTERN int
54971 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
54972 PyObject *str = swig_varlink_str(v);
54973 fprintf(fp,"Swig global variables ");
54974 fprintf(fp,"%s\n", PyString_AsString(str));
54975 Py_DECREF(str);
54976 return 0;
54977 }
54978
54979 SWIGINTERN void
54980 swig_varlink_dealloc(swig_varlinkobject *v) {
54981 swig_globalvar *var = v->vars;
54982 while (var) {
54983 swig_globalvar *n = var->next;
54984 free(var->name);
54985 free(var);
54986 var = n;
54987 }
54988 }
54989
54990 SWIGINTERN PyObject *
54991 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
54992 PyObject *res = NULL;
54993 swig_globalvar *var = v->vars;
54994 while (var) {
54995 if (strcmp(var->name,n) == 0) {
54996 res = (*var->get_attr)();
54997 break;
54998 }
54999 var = var->next;
55000 }
55001 if (res == NULL && !PyErr_Occurred()) {
55002 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55003 }
55004 return res;
55005 }
55006
55007 SWIGINTERN int
55008 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55009 int res = 1;
55010 swig_globalvar *var = v->vars;
55011 while (var) {
55012 if (strcmp(var->name,n) == 0) {
55013 res = (*var->set_attr)(p);
55014 break;
55015 }
55016 var = var->next;
55017 }
55018 if (res == 1 && !PyErr_Occurred()) {
55019 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55020 }
55021 return res;
55022 }
55023
55024 SWIGINTERN PyTypeObject*
55025 swig_varlink_type(void) {
55026 static char varlink__doc__[] = "Swig var link object";
55027 static PyTypeObject varlink_type;
55028 static int type_init = 0;
55029 if (!type_init) {
55030 const PyTypeObject tmp
55031 = {
55032 PyObject_HEAD_INIT(NULL)
55033 0, /* Number of items in variable part (ob_size) */
55034 (char *)"swigvarlink", /* Type name (tp_name) */
55035 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55036 0, /* Itemsize (tp_itemsize) */
55037 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55038 (printfunc) swig_varlink_print, /* Print (tp_print) */
55039 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55040 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55041 0, /* tp_compare */
55042 (reprfunc) swig_varlink_repr, /* tp_repr */
55043 0, /* tp_as_number */
55044 0, /* tp_as_sequence */
55045 0, /* tp_as_mapping */
55046 0, /* tp_hash */
55047 0, /* tp_call */
55048 (reprfunc)swig_varlink_str, /* tp_str */
55049 0, /* tp_getattro */
55050 0, /* tp_setattro */
55051 0, /* tp_as_buffer */
55052 0, /* tp_flags */
55053 varlink__doc__, /* tp_doc */
55054 0, /* tp_traverse */
55055 0, /* tp_clear */
55056 0, /* tp_richcompare */
55057 0, /* tp_weaklistoffset */
55058 #if PY_VERSION_HEX >= 0x02020000
55059 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55060 #endif
55061 #if PY_VERSION_HEX >= 0x02030000
55062 0, /* tp_del */
55063 #endif
55064 #ifdef COUNT_ALLOCS
55065 0,0,0,0 /* tp_alloc -> tp_next */
55066 #endif
55067 };
55068 varlink_type = tmp;
55069 varlink_type.ob_type = &PyType_Type;
55070 type_init = 1;
55071 }
55072 return &varlink_type;
55073 }
55074
55075 /* Create a variable linking object for use later */
55076 SWIGINTERN PyObject *
55077 SWIG_Python_newvarlink(void) {
55078 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55079 if (result) {
55080 result->vars = 0;
55081 }
55082 return ((PyObject*) result);
55083 }
55084
55085 SWIGINTERN void
55086 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55087 swig_varlinkobject *v = (swig_varlinkobject *) p;
55088 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55089 if (gv) {
55090 size_t size = strlen(name)+1;
55091 gv->name = (char *)malloc(size);
55092 if (gv->name) {
55093 strncpy(gv->name,name,size);
55094 gv->get_attr = get_attr;
55095 gv->set_attr = set_attr;
55096 gv->next = v->vars;
55097 }
55098 }
55099 v->vars = gv;
55100 }
55101
55102 SWIGINTERN PyObject *
55103 SWIG_globals() {
55104 static PyObject *_SWIG_globals = 0;
55105 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55106 return _SWIG_globals;
55107 }
55108
55109 /* -----------------------------------------------------------------------------
55110 * constants/methods manipulation
55111 * ----------------------------------------------------------------------------- */
55112
55113 /* Install Constants */
55114 SWIGINTERN void
55115 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55116 PyObject *obj = 0;
55117 size_t i;
55118 for (i = 0; constants[i].type; ++i) {
55119 switch(constants[i].type) {
55120 case SWIG_PY_POINTER:
55121 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55122 break;
55123 case SWIG_PY_BINARY:
55124 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55125 break;
55126 default:
55127 obj = 0;
55128 break;
55129 }
55130 if (obj) {
55131 PyDict_SetItemString(d, constants[i].name, obj);
55132 Py_DECREF(obj);
55133 }
55134 }
55135 }
55136
55137 /* -----------------------------------------------------------------------------*/
55138 /* Fix SwigMethods to carry the callback ptrs when needed */
55139 /* -----------------------------------------------------------------------------*/
55140
55141 SWIGINTERN void
55142 SWIG_Python_FixMethods(PyMethodDef *methods,
55143 swig_const_info *const_table,
55144 swig_type_info **types,
55145 swig_type_info **types_initial) {
55146 size_t i;
55147 for (i = 0; methods[i].ml_name; ++i) {
55148 char *c = methods[i].ml_doc;
55149 if (c && (c = strstr(c, "swig_ptr: "))) {
55150 int j;
55151 swig_const_info *ci = 0;
55152 char *name = c + 10;
55153 for (j = 0; const_table[j].type; ++j) {
55154 if (strncmp(const_table[j].name, name,
55155 strlen(const_table[j].name)) == 0) {
55156 ci = &(const_table[j]);
55157 break;
55158 }
55159 }
55160 if (ci) {
55161 size_t shift = (ci->ptype) - types;
55162 swig_type_info *ty = types_initial[shift];
55163 size_t ldoc = (c - methods[i].ml_doc);
55164 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55165 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55166 if (ndoc) {
55167 char *buff = ndoc;
55168 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55169 if (ptr) {
55170 strncpy(buff, methods[i].ml_doc, ldoc);
55171 buff += ldoc;
55172 strncpy(buff, "swig_ptr: ", 10);
55173 buff += 10;
55174 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55175 methods[i].ml_doc = ndoc;
55176 }
55177 }
55178 }
55179 }
55180 }
55181 }
55182
55183 #ifdef __cplusplus
55184 }
55185 #endif
55186
55187 /* -----------------------------------------------------------------------------*
55188 * Partial Init method
55189 * -----------------------------------------------------------------------------*/
55190
55191 #ifdef __cplusplus
55192 extern "C"
55193 #endif
55194 SWIGEXPORT void SWIG_init(void) {
55195 PyObject *m, *d;
55196
55197 /* Fix SwigMethods to carry the callback ptrs when needed */
55198 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55199
55200 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55201 d = PyModule_GetDict(m);
55202
55203 SWIG_InitializeModule(0);
55204 SWIG_InstallConstants(d,swig_const_table);
55205
55206
55207
55208 #ifndef wxPyUSE_EXPORT
55209 // Make our API structure a CObject so other modules can import it
55210 // from this module.
55211 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55212 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55213 Py_XDECREF(cobj);
55214 #endif
55215
55216 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55217 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55218 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55219 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55220 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55221 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55222 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55223 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55224 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55225 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55226 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55227 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55228 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55229 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55230 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55231 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55232 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55233 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55234 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55235 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55236 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55237 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55238 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55239 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55240 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55241 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55242 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55243 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55244 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55245 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55246 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55247 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55248 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55249 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55250 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55251 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55252 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55253 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55254 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55255 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55256 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55257 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55258 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55259 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55260 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55261 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55262 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55263 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55264 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55265 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55266 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55267 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55268 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55269 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55270 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55271 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55272 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55273 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55274 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55275 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55276 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55277 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55278 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55279 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55280 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55281 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55282 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55283 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55284 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55285 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55286 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55287 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55288 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55289 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55290 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55291 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55292 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55293 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55294 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55295 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55296 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55297 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55298 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55299 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55300 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55301 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55302 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55303 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55304 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55305 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55306 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55307 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55308 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55309 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55310 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55311 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55312 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55313 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55314 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55315 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55316 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55317 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55318 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55319 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55320 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55321 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55322 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55323 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55324 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55325 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55326 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55327 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55328 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55329 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55330 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55331 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55332 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55333 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55334 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55335 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55336 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55337 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55338 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55339 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55340 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55341 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55342 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55343 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55344 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55345 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55346 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55347 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55348 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55349 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55350 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55351 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55352 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55353 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55354 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55355 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55356 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55357 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55358 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55359 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55360 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55361 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55362 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55363 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55364 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55365 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55366 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55367 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55368 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55369 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55370 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55371 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55372 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55373 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55374 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55375 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55376 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55377 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55378 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55379 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55380 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55381 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55382 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55383 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55384 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55385 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55386 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55387 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55388 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55389 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55390 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55391 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55392 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55393 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55394 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55395 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55396 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55397 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55398 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55399 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55400 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55401 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55402 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55403 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55404 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55405 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55406 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55407 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55408 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55409 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55410 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55411 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55412 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55413 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55414 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55415 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55416 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55417 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55418 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55419 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55420 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55421 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55422 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55423 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55424 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55425 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55426 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55427 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55428 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55429 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55430 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55431 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55432 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55433 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55434 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55435 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55436 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55437 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55438 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55439 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55440 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55441 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55442 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55443 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55444 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55445 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55446 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55447 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55448 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55449 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55450 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55451 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55452 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55453 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55454 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55455 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55456 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55457 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55458 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55459 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55460 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55461 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55462 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55463 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55464 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55465 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55466 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55467 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55468 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55469 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55470 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55471 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55472 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55473 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55474 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55475 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55476 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55477 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55478 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55479 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55480 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55481 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55482 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55483 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55484 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55485 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55486 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55487 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55488 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55489 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55490 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55491 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55492 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55493 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55494 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55495 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55496 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55497 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55498 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55499 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55500 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55501 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55502 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55503 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55504 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55505 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55506 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55507 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55508 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55509 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55510 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55511 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55512 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55513 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55514 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55515 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55516 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55517 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55518 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55519 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55520 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55521 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55522 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55523 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55524 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55525 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55526 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55527 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55528 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55529 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55530 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55531 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55532 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55533 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55534 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55535 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55536 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55537 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55538 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55539 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55540 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55541 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55542 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55543 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55544 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55545 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55546 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55547 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55548 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55549 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55550 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55551 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55552 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55553 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55554 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55555 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55556 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55557 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55558 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55559 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55560 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55561 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55562 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55563 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55564 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55565 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55566 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55567 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55568 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55569 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55570 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55571 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55572 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55573 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55574 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55575 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55576 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55577 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55578 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55579 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55580 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55581 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55582 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55583 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55584 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55585 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55586 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55587 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55588 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55589 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55590 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55591 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55592 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55593 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55594 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55595 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55596 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55597 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55598 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55599 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55600 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55601 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55602 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55603 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55604 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55605 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55606 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55607 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55608 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55609 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55610 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55611 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55612 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55613 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55614 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55615 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55616 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55617 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55618 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55619 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55620 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55621 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55622 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55623 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55624 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55625 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55626 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55627 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55628 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55629 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55630 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55631 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55632 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55633 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55634 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55635 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55636 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55637 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55638 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55639 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55640 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55641 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55642 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55643 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55644 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55645 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55646 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55647 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55648 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55649 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55650 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55651 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55652 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55653 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55654 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55655 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55656 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55657 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55658 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55659 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55660 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55661 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55662 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55663 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55664 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55665 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55666 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55667 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55668 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55669 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55670 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55671 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55672 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55673 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55674 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55675 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55676 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55677 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55678 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55679 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55680 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55681 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55682 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55683 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55684 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55685 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55686 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55687 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55688 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55689 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55690 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55691 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55692 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55693 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55694 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55695 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55696 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55697 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55698 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55699 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55700 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55701 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55702 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55703 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55704 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55705 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55706 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55707 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55708 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55709 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55710 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55711 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55712 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55713 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55714 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55715 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55716 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55717 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55718 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55719 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55720 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55721 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55722 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55723 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55724 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55725 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55726 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55727 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55728 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55729 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55730 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55731 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55732 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55733 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55734 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55735 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55736 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55737 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55738 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55739 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55740 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55741 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55742 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55743 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55744 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55745 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55746 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55747 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55748 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55749 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55750 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55751 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55752 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55753 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55754 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55755 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55756 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55757 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55758 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55759 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55760 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55761 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55762 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55763 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55764 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55765 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55766 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55767 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55768 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55769 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55770 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55771 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55772 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55773 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55774 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55775 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55776 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55777 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55778 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55779 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55780 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55781 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55782 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55783 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55784 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55785 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55786 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55787 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55788 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55789 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55790 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55791 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55792 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55793 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55794 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55795 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55796 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55797 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55798 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55799 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55800 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55801 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55802 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55803 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55804 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55805 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55806 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55807 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55808 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55809 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55810 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55811 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55812 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55813 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55814 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55815 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55816 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55817 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55818 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55819 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55820 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55821 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55822 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55823 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55824 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55825 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55826 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55827 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55828 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55829 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55830 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55831 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55832 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55833 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55834 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55835 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55836 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55837 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55838 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55839 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55840 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55841 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55842 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55843 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55844 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55845 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55846 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55847 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55848 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55849 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55850 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55851 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55852 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55853 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55854 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55855 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55856 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55857 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55858 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55859 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55860 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55861 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55862 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55863 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55864 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55865 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55866 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
55867 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
55868 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
55869 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
55870 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
55871 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
55872 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
55873 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
55874 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
55875 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
55876 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
55877 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
55878 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
55879 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
55880 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
55881 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
55882 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
55883 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
55884 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
55885
55886 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
55887
55888
55889 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
55890
55891 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
55892 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
55893 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
55894 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
55895 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
55896 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
55897 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
55898 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
55899 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
55900 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
55901 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
55902 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
55903 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
55904 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
55905 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
55906 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
55907 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
55908 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
55909 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
55910 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
55911 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
55912 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
55913 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
55914 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
55915 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
55916 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
55917 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
55918 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
55919 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
55920 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
55921 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
55922 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
55923 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
55924 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
55925 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
55926 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
55927 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
55928 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
55929 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
55930 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
55931 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
55932 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
55933 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
55934 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
55935 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
55936 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
55937 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
55938 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
55939 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
55940 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
55941 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
55942 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
55943 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
55944 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
55945 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
55946 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
55947 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
55948 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
55949 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
55950 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
55951 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
55952 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
55953 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
55954 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
55955 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
55956 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
55957 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
55958 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
55959 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
55960 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
55961 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
55962 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
55963 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
55964 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
55965 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
55966 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
55967 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
55968 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
55969 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
55970 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
55971 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
55972 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
55973 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
55974 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
55975 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
55976 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
55977 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
55978 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
55979 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
55980 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
55981 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
55982 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
55983 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
55984 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
55985 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
55986 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
55987 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
55988 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
55989 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
55990 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
55991 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
55992 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
55993 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
55994 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
55995 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
55996 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
55997 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
55998 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
55999 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56000 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56001 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56002 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56003 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56004 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56005 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56006 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56007 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56008 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56009 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56010 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56011 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56012 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56013 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56014 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56015 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56016 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56017 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56018 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56019 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56020 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56021 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56022 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56023 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56024 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56025 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56026 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56027 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56028 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56029 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56030 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56031 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56032 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56033 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56034 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56035 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56036 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56037 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56038 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56039 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56040 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56041 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56042 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56043 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56044 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56045 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56046 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56047 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56048 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56049 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56050 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56051 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56052 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56053 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56054 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56055 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56056 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56057 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56058 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56059 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56060 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56061 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56062 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56063 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56064 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56065 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56066 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56067 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56068 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56069 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56070 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56071 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56072 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56073 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56074 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56075 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56076 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56077 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56078 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56079 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56080 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56081 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56082 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56083 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56084 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56085 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56086 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56087 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56088 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56089 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56090 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56091 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56092 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56093 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56094 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56095
56096 // Initialize threading, some globals and such
56097 __wxPyPreStart(d);
56098
56099
56100 // Although these are defined in __version__ they need to be here too so
56101 // that an assert can be done to ensure that the wxPython and the wxWindows
56102 // versions match.
56103 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56104 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56105 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56106
56107 }
56108
wxWidgets (Impactor)