]> 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
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2983 PyObject* tup = PyTuple_New(2);
2984 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2985 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2986 wxPyEndBlockThreads(blocked);
2987 return tup;
2988 }
2989
2990 SWIGINTERN int
2991 SWIG_AsVal_double (PyObject *obj, double* val)
2992 {
2993 if (PyNumber_Check(obj)) {
2994 if (val) *val = PyFloat_AsDouble(obj);
2995 return SWIG_OK;
2996 }
2997 return SWIG_TypeError;
2998 }
2999
3000
3001 #define SWIG_From_double PyFloat_FromDouble
3002
3003 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3004 wxRealPoint temp, *obj = &temp;
3005 if ( other == Py_None ) return false;
3006 if ( ! wxRealPoint_helper(other, &obj) ) {
3007 PyErr_Clear();
3008 return false;
3009 }
3010 return self->operator==(*obj);
3011 }
3012 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3013 wxRealPoint temp, *obj = &temp;
3014 if ( other == Py_None ) return true;
3015 if ( ! wxRealPoint_helper(other, &obj)) {
3016 PyErr_Clear();
3017 return true;
3018 }
3019 return self->operator!=(*obj);
3020 }
3021 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3022 self->x = x;
3023 self->y = y;
3024 }
3025 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 PyObject* tup = PyTuple_New(2);
3028 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3029 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3030 wxPyEndBlockThreads(blocked);
3031 return tup;
3032 }
3033 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3034 wxPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return false;
3036 if ( ! wxPoint_helper(other, &obj) ) {
3037 PyErr_Clear();
3038 return false;
3039 }
3040 return self->operator==(*obj);
3041 }
3042 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3043 wxPoint temp, *obj = &temp;
3044 if ( other == Py_None ) return true;
3045 if ( ! wxPoint_helper(other, &obj)) {
3046 PyErr_Clear();
3047 return true;
3048 }
3049 return self->operator!=(*obj);
3050 }
3051 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3052 self->x = x;
3053 self->y = y;
3054 }
3055 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 PyObject* tup = PyTuple_New(2);
3058 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3059 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3060 wxPyEndBlockThreads(blocked);
3061 return tup;
3062 }
3063 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3064 wxRect temp, *obj = &temp;
3065 if ( other == Py_None ) return false;
3066 if ( ! wxRect_helper(other, &obj) ) {
3067 PyErr_Clear();
3068 return false;
3069 }
3070 return self->operator==(*obj);
3071 }
3072 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3073 wxRect temp, *obj = &temp;
3074 if ( other == Py_None ) return true;
3075 if ( ! wxRect_helper(other, &obj)) {
3076 PyErr_Clear();
3077 return true;
3078 }
3079 return self->operator!=(*obj);
3080 }
3081 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3082 self->x = x;
3083 self->y = y;
3084 self->width = width;
3085 self->height = height;
3086 }
3087 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3089 PyObject* tup = PyTuple_New(4);
3090 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3091 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3092 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3093 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3094 wxPyEndBlockThreads(blocked);
3095 return tup;
3096 }
3097
3098 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3099 wxRegion reg1(*r1);
3100 wxRegion reg2(*r2);
3101 wxRect dest(0,0,0,0);
3102 PyObject* obj;
3103
3104 reg1.Intersect(reg2);
3105 dest = reg1.GetBox();
3106
3107 if (dest != wxRect(0,0,0,0)) {
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxRect* newRect = new wxRect(dest);
3110 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3111 wxPyEndBlockThreads(blocked);
3112 return obj;
3113 }
3114 Py_INCREF(Py_None);
3115 return Py_None;
3116 }
3117
3118 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3119 wxPoint2D temp, *obj = &temp;
3120 if ( other == Py_None ) return false;
3121 if ( ! wxPoint2D_helper(other, &obj) ) {
3122 PyErr_Clear();
3123 return false;
3124 }
3125 return self->operator==(*obj);
3126 }
3127 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3128 wxPoint2D temp, *obj = &temp;
3129 if ( other == Py_None ) return true;
3130 if ( ! wxPoint2D_helper(other, &obj)) {
3131 PyErr_Clear();
3132 return true;
3133 }
3134 return self->operator!=(*obj);
3135 }
3136 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3137 self->m_x = x;
3138 self->m_y = y;
3139 }
3140 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 PyObject* tup = PyTuple_New(2);
3143 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3144 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3145 wxPyEndBlockThreads(blocked);
3146 return tup;
3147 }
3148
3149 #include "wx/wxPython/pyistream.h"
3150
3151 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3152 wxInputStream* wxis = wxPyCBInputStream::create(p);
3153 if (wxis)
3154 return new wxPyInputStream(wxis);
3155 else
3156 return NULL;
3157 }
3158
3159 SWIGINTERN swig_type_info*
3160 SWIG_pchar_descriptor()
3161 {
3162 static int init = 0;
3163 static swig_type_info* info = 0;
3164 if (!init) {
3165 info = SWIG_TypeQuery("_p_char");
3166 init = 1;
3167 }
3168 return info;
3169 }
3170
3171
3172 SWIGINTERNINLINE PyObject *
3173 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3174 {
3175 if (carray) {
3176 if (size > INT_MAX) {
3177 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3178 return pchar_descriptor ?
3179 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3180 } else {
3181 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3182 }
3183 } else {
3184 return SWIG_Py_Void();
3185 }
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject *
3190 SWIG_From_char (char c)
3191 {
3192 return SWIG_FromCharPtrAndSize(&c,1);
3193 }
3194
3195
3196 SWIGINTERNINLINE PyObject*
3197 SWIG_From_unsigned_SS_long (unsigned long value)
3198 {
3199 return (value > LONG_MAX) ?
3200 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3201 }
3202
3203
3204 SWIGINTERNINLINE PyObject *
3205 SWIG_From_size_t (size_t value)
3206 {
3207 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3208 }
3209
3210
3211 SWIGINTERN int
3212 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3213 {
3214 if (PyString_Check(obj)) {
3215 char *cstr; Py_ssize_t len;
3216 PyString_AsStringAndSize(obj, &cstr, &len);
3217 if (cptr) {
3218 if (alloc) {
3219 /*
3220 In python the user should not be able to modify the inner
3221 string representation. To warranty that, if you define
3222 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3223 buffer is always returned.
3224
3225 The default behavior is just to return the pointer value,
3226 so, be careful.
3227 */
3228 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3229 if (*alloc != SWIG_OLDOBJ)
3230 #else
3231 if (*alloc == SWIG_NEWOBJ)
3232 #endif
3233 {
3234 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3235 *alloc = SWIG_NEWOBJ;
3236 }
3237 else {
3238 *cptr = cstr;
3239 *alloc = SWIG_OLDOBJ;
3240 }
3241 } else {
3242 *cptr = PyString_AsString(obj);
3243 }
3244 }
3245 if (psize) *psize = len + 1;
3246 return SWIG_OK;
3247 } else {
3248 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3249 if (pchar_descriptor) {
3250 void* vptr = 0;
3251 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3252 if (cptr) *cptr = (char *) vptr;
3253 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3254 if (alloc) *alloc = SWIG_OLDOBJ;
3255 return SWIG_OK;
3256 }
3257 }
3258 }
3259 return SWIG_TypeError;
3260 }
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3265 {
3266 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3267 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3268 if (SWIG_IsOK(res)) {
3269 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3270 if (csize <= size) {
3271 if (val) {
3272 if (csize) memcpy(val, cptr, csize*sizeof(char));
3273 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3274 }
3275 if (alloc == SWIG_NEWOBJ) {
3276 delete[] cptr;
3277 res = SWIG_DelNewMask(res);
3278 }
3279 return res;
3280 }
3281 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3282 }
3283 return SWIG_TypeError;
3284 }
3285
3286
3287 SWIGINTERN int
3288 SWIG_AsVal_char (PyObject * obj, char *val)
3289 {
3290 int res = SWIG_AsCharArray(obj, val, 1);
3291 if (!SWIG_IsOK(res)) {
3292 long v;
3293 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3294 if (SWIG_IsOK(res)) {
3295 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3296 if (val) *val = static_cast< char >(v);
3297 } else {
3298 res = SWIG_OverflowError;
3299 }
3300 }
3301 }
3302 return res;
3303 }
3304
3305 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3306 // We use only strings for the streams, not unicode
3307 PyObject* str = PyObject_Str(obj);
3308 if (! str) {
3309 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3310 return;
3311 }
3312 self->Write(PyString_AS_STRING(str),
3313 PyString_GET_SIZE(str));
3314 Py_DECREF(str);
3315 }
3316
3317 #include "wx/wxPython/pyistream.h"
3318
3319
3320 class wxPyFileSystemHandler : public wxFileSystemHandler
3321 {
3322 public:
3323 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3324
3325 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3326 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3327 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3328 DEC_PYCALLBACK_STRING__pure(FindNext);
3329
3330 wxString GetProtocol(const wxString& location) {
3331 return wxFileSystemHandler::GetProtocol(location);
3332 }
3333
3334 wxString GetLeftLocation(const wxString& location) {
3335 return wxFileSystemHandler::GetLeftLocation(location);
3336 }
3337
3338 wxString GetAnchor(const wxString& location) {
3339 return wxFileSystemHandler::GetAnchor(location);
3340 }
3341
3342 wxString GetRightLocation(const wxString& location) {
3343 return wxFileSystemHandler::GetRightLocation(location);
3344 }
3345
3346 wxString GetMimeTypeFromExt(const wxString& location) {
3347 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3348 }
3349
3350 PYPRIVATE;
3351 };
3352
3353
3354 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3355 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3356 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3357 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3358
3359
3360 SWIGINTERN int
3361 SWIG_AsVal_bool (PyObject *obj, bool *val)
3362 {
3363 if (obj == Py_True) {
3364 if (val) *val = true;
3365 return SWIG_OK;
3366 } else if (obj == Py_False) {
3367 if (val) *val = false;
3368 return SWIG_OK;
3369 } else {
3370 long v = 0;
3371 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3372 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3373 return res;
3374 }
3375 }
3376
3377 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3378 wxFileName fname = wxFileSystem::URLToFileName(url);
3379 return fname.GetFullPath();
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3383 wxImage& image,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, image, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3389 const wxBitmap& bitmap,
3390 long type) {
3391 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3392 }
3393
3394 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3395 PyObject* data) {
3396 if (! PyString_Check(data)) {
3397 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3398 "Expected string object"));
3399 return;
3400 }
3401
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 void* ptr = (void*)PyString_AsString(data);
3404 size_t size = PyString_Size(data);
3405 wxPyEndBlockThreads(blocked);
3406
3407 wxMemoryFSHandler::AddFile(filename, ptr, size);
3408 }
3409
3410
3411 #include "wx/wxPython/pyistream.h"
3412
3413
3414 SWIGINTERN int
3415 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3416 {
3417 long v = 0;
3418 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3419 return SWIG_TypeError;
3420 }
3421 else if (val)
3422 *val = (unsigned long)v;
3423 return SWIG_OK;
3424 }
3425
3426
3427 SWIGINTERN int
3428 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3429 {
3430 unsigned long v;
3431 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3432 if (SWIG_IsOK(res)) {
3433 if ((v > UCHAR_MAX)) {
3434 return SWIG_OverflowError;
3435 } else {
3436 if (val) *val = static_cast< unsigned char >(v);
3437 }
3438 }
3439 return res;
3440 }
3441
3442
3443 SWIGINTERNINLINE PyObject *
3444 SWIG_From_unsigned_SS_char (unsigned char value)
3445 {
3446 return SWIG_From_unsigned_SS_long (value);
3447 }
3448
3449 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3454 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3459 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3460 colour.Green(),
3461 colour.Blue());
3462 wxImageHistogramEntry e = (*self)[key];
3463 return e.value;
3464 }
3465
3466 typedef unsigned char* buffer;
3467
3468
3469 // Pull the nested class out to the top level for SWIG's sake
3470 #define wxImage_RGBValue wxImage::RGBValue
3471 #define wxImage_HSVValue wxImage::HSVValue
3472
3473 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3474 if (width > 0 && height > 0)
3475 return new wxImage(width, height, clear);
3476 else
3477 return new wxImage;
3478 }
3479 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3480 return new wxImage(bitmap.ConvertToImage());
3481 }
3482 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3483 if (DATASIZE != width*height*3) {
3484 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3485 return NULL;
3486 }
3487
3488 // Copy the source data so the wxImage can clean it up later
3489 buffer copy = (buffer)malloc(DATASIZE);
3490 if (copy == NULL) {
3491 wxPyBLOCK_THREADS(PyErr_NoMemory());
3492 return NULL;
3493 }
3494 memcpy(copy, data, DATASIZE);
3495 return new wxImage(width, height, copy, false);
3496 }
3497 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3498 if (DATASIZE != width*height*3) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3500 return NULL;
3501 }
3502 if (ALPHASIZE != width*height) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer dcopy = (buffer)malloc(DATASIZE);
3509 if (dcopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(dcopy, data, DATASIZE);
3514
3515 buffer acopy = (buffer)malloc(ALPHASIZE);
3516 if (acopy == NULL) {
3517 wxPyBLOCK_THREADS(PyErr_NoMemory());
3518 return NULL;
3519 }
3520 memcpy(acopy, alpha, ALPHASIZE);
3521
3522 return new wxImage(width, height, dcopy, acopy, false);
3523 }
3524 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3525 wxSize size(self->GetWidth(), self->GetHeight());
3526 return size;
3527 }
3528 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3529 buffer data = self->GetData();
3530 int len = self->GetWidth() * self->GetHeight() * 3;
3531 PyObject* rv;
3532 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3533 return rv;
3534 }
3535 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3536 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3537 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3538 return;
3539 }
3540 buffer copy = (buffer)malloc(DATASIZE);
3541 if (copy == NULL) {
3542 wxPyBLOCK_THREADS(PyErr_NoMemory());
3543 return;
3544 }
3545 memcpy(copy, data, DATASIZE);
3546 self->SetData(copy, false);
3547 // wxImage takes ownership of copy...
3548 }
3549 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3550 buffer data = self->GetData();
3551 int len = self->GetWidth() * self->GetHeight() * 3;
3552 PyObject* rv;
3553 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3554 return rv;
3555 }
3556 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3557 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return;
3560 }
3561 self->SetData(data, true);
3562 }
3563 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3564 buffer data = self->GetAlpha();
3565 if (! data) {
3566 RETURN_NONE();
3567 } else {
3568 int len = self->GetWidth() * self->GetHeight();
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3571 return rv;
3572 }
3573 }
3574 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3575 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3577 return;
3578 }
3579 buffer acopy = (buffer)malloc(ALPHASIZE);
3580 if (acopy == NULL) {
3581 wxPyBLOCK_THREADS(PyErr_NoMemory());
3582 return;
3583 }
3584 memcpy(acopy, alpha, ALPHASIZE);
3585 self->SetAlpha(acopy, false);
3586 // wxImage takes ownership of acopy...
3587 }
3588 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3589 buffer data = self->GetAlpha();
3590 int len = self->GetWidth() * self->GetHeight();
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3596 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3598 return;
3599 }
3600 self->SetAlpha(alpha, true);
3601 }
3602 SWIGINTERN PyObject *wxImage_GetHandlers(){
3603 wxList& list = wxImage::GetHandlers();
3604 return wxPy_ConvertList(&list);
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3607 wxBitmap bitmap(*self, depth);
3608 return bitmap;
3609 }
3610 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3611 wxImage mono = self->ConvertToMono( red, green, blue );
3612 wxBitmap bitmap( mono, 1 );
3613 return bitmap;
3614 }
3615 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3616 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3617 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3618 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3619 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3620 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3621 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3622 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3623 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3624 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3625 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3626 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3627 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3628 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3629 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3630
3631 #include <wx/quantize.h>
3632
3633 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3634 return wxQuantize::Quantize(src, dest,
3635 //NULL, // palette
3636 desiredNoColours,
3637 NULL, // eightBitData
3638 flags);
3639 }
3640 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3641 if (PyCallable_Check(func)) {
3642 self->Connect(id, lastId, eventType,
3643 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3644 new wxPyCallback(func));
3645 }
3646 else if (func == Py_None) {
3647 self->Disconnect(id, lastId, eventType,
3648 (wxObjectEventFunction)
3649 &wxPyCallback::EventThunker);
3650 }
3651 else {
3652 wxPyBLOCK_THREADS(
3653 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3654 }
3655 }
3656 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3657 return self->Disconnect(id, lastId, eventType,
3658 (wxObjectEventFunction)
3659 &wxPyCallback::EventThunker);
3660 }
3661 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3662 if (_self && _self != Py_None) {
3663 self->SetClientObject(new wxPyOORClientData(_self, incref));
3664 }
3665 else {
3666 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3667 if (data) {
3668 self->SetClientObject(NULL); // This will delete it too
3669 }
3670 }
3671 }
3672
3673 #if ! wxUSE_HOTKEY
3674 #define wxEVT_HOTKEY -9999
3675 #endif
3676
3677 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3678 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3679 if (data) {
3680 Py_INCREF(data->m_obj);
3681 return data->m_obj;
3682 } else {
3683 Py_INCREF(Py_None);
3684 return Py_None;
3685 }
3686 }
3687 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3688 wxPyClientData* data = new wxPyClientData(clientData);
3689 self->SetClientObject(data);
3690 }
3691 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3692 #if wxUSE_UNICODE
3693 return self->GetUnicodeKey();
3694 #else
3695 return 0;
3696 #endif
3697 }
3698 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3699 #if wxUSE_UNICODE
3700 self->m_uniChar = uniChar;
3701 #endif
3702 }
3703
3704 SWIGINTERNINLINE PyObject *
3705 SWIG_From_unsigned_SS_int (unsigned int value)
3706 {
3707 return SWIG_From_unsigned_SS_long (value);
3708 }
3709
3710
3711 SWIGINTERN int
3712 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3713 {
3714 unsigned long v;
3715 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3716 if (SWIG_IsOK(res)) {
3717 if ((v > UINT_MAX)) {
3718 return SWIG_OverflowError;
3719 } else {
3720 if (val) *val = static_cast< unsigned int >(v);
3721 }
3722 }
3723 return res;
3724 }
3725
3726 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3727 self->m_size = size;
3728 }
3729 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3730 int count = self->GetNumberOfFiles();
3731 wxString* files = self->GetFiles();
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734
3735 if (!list) {
3736 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3737 wxPyEndBlockThreads(blocked);
3738 return NULL;
3739 }
3740
3741 for (int i=0; i<count; i++) {
3742 PyList_SetItem(list, i, wx2PyString(files[i]));
3743 }
3744 wxPyEndBlockThreads(blocked);
3745 return list;
3746 }
3747
3748
3749 SWIGINTERN wxPyApp *new_wxPyApp(){
3750 wxPythonApp = new wxPyApp();
3751 return wxPythonApp;
3752 }
3753 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3754
3755 void wxApp_CleanUp() {
3756 __wxPyCleanup();
3757 }
3758
3759
3760 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3761
3762
3763
3764
3765
3766 SWIGINTERNINLINE PyObject *
3767 SWIG_FromCharPtr(const char *cptr)
3768 {
3769 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3770 }
3771
3772
3773 #if 0 // #ifdef __WXMAC__
3774
3775 // A dummy class that raises an exception if used...
3776 class wxEventLoop
3777 {
3778 public:
3779 wxEventLoop() { wxPyRaiseNotImplemented(); }
3780 int Run() { return 0; }
3781 void Exit(int rc = 0) {}
3782 bool Pending() const { return false; }
3783 bool Dispatch() { return false; }
3784 bool IsRunning() const { return false; }
3785 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3786 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3787 };
3788
3789 #else
3790
3791 #include <wx/evtloop.h>
3792
3793 #endif
3794
3795
3796
3797 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3798 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3799 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3800 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3801 wxWindowList& list = self->GetChildren();
3802 return wxPy_ConvertList(&list);
3803 }
3804 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3805 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3806 #if wxUSE_HOTKEY
3807 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3808 #else
3809 return false;
3810 #endif
3811 }
3812 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3813
3814
3815
3816 return false;
3817
3818 }
3819 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3820 return wxPyGetWinHandle(self);
3821 }
3822 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3823 self->AssociateHandle((WXWidget)handle);
3824 }
3825 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3826
3827 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3828 return wxWindow::FindWindowById(id, parent);
3829 }
3830
3831 wxWindow* wxFindWindowByName( const wxString& name,
3832 const wxWindow *parent = NULL ) {
3833 return wxWindow::FindWindowByName(name, parent);
3834 }
3835
3836 wxWindow* wxFindWindowByLabel( const wxString& label,
3837 const wxWindow *parent = NULL ) {
3838 return wxWindow::FindWindowByLabel(label, parent);
3839 }
3840
3841
3842 #ifdef __WXMSW__
3843 #include <wx/msw/private.h> // to get wxGetWindowId
3844 #endif
3845
3846
3847 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3848 #ifdef __WXMSW__
3849 WXHWND hWnd = (WXHWND)_hWnd;
3850 long id = wxGetWindowId(hWnd);
3851 wxWindow* win = new wxWindow;
3852 if (parent)
3853 parent->AddChild(win);
3854 win->SetEventHandler(win);
3855 win->SetHWND(hWnd);
3856 win->SetId(id);
3857 win->SubclassWin(hWnd);
3858 win->AdoptAttributesFromHWND();
3859 win->SetupColours();
3860 return win;
3861 #else
3862 wxPyRaiseNotImplemented();
3863 return NULL;
3864 #endif
3865 }
3866
3867
3868 PyObject* GetTopLevelWindows() {
3869 return wxPy_ConvertList(&wxTopLevelWindows);
3870 }
3871
3872
3873 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3874 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3875 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3876
3877 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3878
3879
3880 SWIGINTERNINLINE int
3881 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3882 {
3883 unsigned long v;
3884 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3885 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3886 return res;
3887 }
3888
3889 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3890 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3891 wxMenuItemList& list = self->GetMenuItems();
3892 return wxPy_ConvertList(&list);
3893 }
3894 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3895 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3896 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3897 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3898 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3899 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3900 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3901 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3902 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3903 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3904 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3905 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3906 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3907 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3908 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3909 static const wxString wxPyControlNameStr(wxControlNameStr);
3910 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3911 if (clientData) {
3912 wxPyClientData* data = new wxPyClientData(clientData);
3913 return self->Append(item, data);
3914 } else
3915 return self->Append(item);
3916 }
3917 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3918 if (clientData) {
3919 wxPyClientData* data = new wxPyClientData(clientData);
3920 return self->Insert(item, pos, data);
3921 } else
3922 return self->Insert(item, pos);
3923 }
3924 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3925 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3926 if (data) {
3927 Py_INCREF(data->m_obj);
3928 return data->m_obj;
3929 } else {
3930 Py_INCREF(Py_None);
3931 return Py_None;
3932 }
3933 }
3934 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3935 wxPyClientData* data = new wxPyClientData(clientData);
3936 self->SetClientObject(n, data);
3937 }
3938
3939
3940 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3941 wxPyUserData* data = NULL;
3942 if ( userData ) {
3943 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3944 data = new wxPyUserData(userData);
3945 wxPyEndBlockThreads(blocked);
3946 }
3947 return new wxSizerItem(window, proportion, flag, border, data);
3948 }
3949 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3950 wxPyUserData* data = NULL;
3951 if ( userData ) {
3952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3953 data = new wxPyUserData(userData);
3954 wxPyEndBlockThreads(blocked);
3955 }
3956 return new wxSizerItem(width, height, proportion, flag, border, data);
3957 }
3958 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3959 wxPyUserData* data = NULL;
3960 if ( userData ) {
3961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3962 data = new wxPyUserData(userData);
3963 wxPyEndBlockThreads(blocked);
3964 }
3965 return new wxSizerItem(sizer, proportion, flag, border, data);
3966 }
3967
3968 #include <float.h>
3969
3970
3971 SWIGINTERN int
3972 SWIG_AsVal_float (PyObject * obj, float *val)
3973 {
3974 double v;
3975 int res = SWIG_AsVal_double (obj, &v);
3976 if (SWIG_IsOK(res)) {
3977 if ((v < -FLT_MAX || v > FLT_MAX)) {
3978 return SWIG_OverflowError;
3979 } else {
3980 if (val) *val = static_cast< float >(v);
3981 }
3982 }
3983 return res;
3984 }
3985
3986
3987 SWIGINTERNINLINE PyObject *
3988 SWIG_From_float (float value)
3989 {
3990 return SWIG_From_double (value);
3991 }
3992
3993 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3994 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3995 if (data) {
3996 Py_INCREF(data->m_obj);
3997 return data->m_obj;
3998 } else {
3999 Py_INCREF(Py_None);
4000 return Py_None;
4001 }
4002 }
4003 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4004 wxPyUserData* data = NULL;
4005 if ( userData ) {
4006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4007 data = new wxPyUserData(userData);
4008 wxPyEndBlockThreads(blocked);
4009 }
4010 self->SetUserData(data);
4011 }
4012
4013 // Figure out the type of the sizer item
4014
4015 struct wxPySizerItemInfo {
4016 wxPySizerItemInfo()
4017 : window(NULL), sizer(NULL), gotSize(false),
4018 size(wxDefaultSize), gotPos(false), pos(-1)
4019 {}
4020
4021 wxWindow* window;
4022 wxSizer* sizer;
4023 bool gotSize;
4024 wxSize size;
4025 bool gotPos;
4026 int pos;
4027 };
4028
4029 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4030
4031 wxPySizerItemInfo info;
4032 wxSize size;
4033 wxSize* sizePtr = &size;
4034
4035 // Find out what the type of the item is
4036 // try wxWindow
4037 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4038 PyErr_Clear();
4039 info.window = NULL;
4040
4041 // try wxSizer
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4043 PyErr_Clear();
4044 info.sizer = NULL;
4045
4046 // try wxSize or (w,h)
4047 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4048 info.size = *sizePtr;
4049 info.gotSize = true;
4050 }
4051
4052 // or a single int
4053 if (checkIdx && PyInt_Check(item)) {
4054 info.pos = PyInt_AsLong(item);
4055 info.gotPos = true;
4056 }
4057 }
4058 }
4059
4060 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4061 // no expected type, figure out what kind of error message to generate
4062 if ( !checkSize && !checkIdx )
4063 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4064 else if ( checkSize && !checkIdx )
4065 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4066 else if ( !checkSize && checkIdx)
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4068 else
4069 // can this one happen?
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4071 }
4072
4073 return info;
4074 }
4075
4076 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4077 if (!self->GetClientObject())
4078 self->SetClientObject(new wxPyOORClientData(_self));
4079 }
4080 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4081
4082 wxPyUserData* data = NULL;
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4085 if ( userData && (info.window || info.sizer || info.gotSize) )
4086 data = new wxPyUserData(userData);
4087 if ( info.sizer )
4088 PyObject_SetAttrString(item,"thisown",Py_False);
4089 wxPyEndBlockThreads(blocked);
4090
4091 // Now call the real Add method if a valid item type was found
4092 if ( info.window )
4093 return self->Add(info.window, proportion, flag, border, data);
4094 else if ( info.sizer )
4095 return self->Add(info.sizer, proportion, flag, border, data);
4096 else if (info.gotSize)
4097 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4098 proportion, flag, border, data);
4099 else
4100 return NULL;
4101 }
4102 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4103
4104 wxPyUserData* data = NULL;
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4107 if ( userData && (info.window || info.sizer || info.gotSize) )
4108 data = new wxPyUserData(userData);
4109 if ( info.sizer )
4110 PyObject_SetAttrString(item,"thisown",Py_False);
4111 wxPyEndBlockThreads(blocked);
4112
4113 // Now call the real Insert method if a valid item type was found
4114 if ( info.window )
4115 return self->Insert(before, info.window, proportion, flag, border, data);
4116 else if ( info.sizer )
4117 return self->Insert(before, info.sizer, proportion, flag, border, data);
4118 else if (info.gotSize)
4119 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4120 proportion, flag, border, data);
4121 else
4122 return NULL;
4123 }
4124 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4125
4126 wxPyUserData* data = NULL;
4127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4129 if ( userData && (info.window || info.sizer || info.gotSize) )
4130 data = new wxPyUserData(userData);
4131 if ( info.sizer )
4132 PyObject_SetAttrString(item,"thisown",Py_False);
4133 wxPyEndBlockThreads(blocked);
4134
4135 // Now call the real Prepend method if a valid item type was found
4136 if ( info.window )
4137 return self->Prepend(info.window, proportion, flag, border, data);
4138 else if ( info.sizer )
4139 return self->Prepend(info.sizer, proportion, flag, border, data);
4140 else if (info.gotSize)
4141 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4142 proportion, flag, border, data);
4143 else
4144 return NULL;
4145 }
4146 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4149 wxPyEndBlockThreads(blocked);
4150 if ( info.window )
4151 return self->Remove(info.window);
4152 else if ( info.sizer )
4153 return self->Remove(info.sizer);
4154 else if ( info.gotPos )
4155 return self->Remove(info.pos);
4156 else
4157 return false;
4158 }
4159 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4161 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4162 wxPyEndBlockThreads(blocked);
4163 if ( info.window )
4164 return self->Detach(info.window);
4165 else if ( info.sizer )
4166 return self->Detach(info.sizer);
4167 else if ( info.gotPos )
4168 return self->Detach(info.pos);
4169 else
4170 return false;
4171 }
4172 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 return self->GetItem(info.window);
4178 else if ( info.sizer )
4179 return self->GetItem(info.sizer);
4180 else if ( info.gotPos )
4181 return self->GetItem(info.pos);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 self->SetItemMinSize(info.window, size);
4191 else if ( info.sizer )
4192 self->SetItemMinSize(info.sizer, size);
4193 else if ( info.gotPos )
4194 self->SetItemMinSize(info.pos, size);
4195 }
4196 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4197 wxSizerItemList& list = self->GetChildren();
4198 return wxPy_ConvertList(&list);
4199 }
4200 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4203 wxPyEndBlockThreads(blocked);
4204 if ( info.window )
4205 return self->Show(info.window, show, recursive);
4206 else if ( info.sizer )
4207 return self->Show(info.sizer, show, recursive);
4208 else if ( info.gotPos )
4209 return self->Show(info.pos, show);
4210 else
4211 return false;
4212 }
4213 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4216 wxPyEndBlockThreads(blocked);
4217 if ( info.window )
4218 return self->IsShown(info.window);
4219 else if ( info.sizer )
4220 return self->IsShown(info.sizer);
4221 else if ( info.gotPos )
4222 return self->IsShown(info.pos);
4223 else
4224 return false;
4225 }
4226
4227 // See pyclasses.h
4228 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4229 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4230 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4231
4232
4233
4234
4235 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4236 {
4237 if (source == Py_None) {
4238 **obj = wxGBPosition(-1,-1);
4239 return true;
4240 }
4241 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4242 }
4243
4244 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4245 {
4246 if (source == Py_None) {
4247 **obj = wxGBSpan(-1,-1);
4248 return true;
4249 }
4250 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4251 }
4252
4253
4254 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4255 wxGBPosition temp, *obj = &temp;
4256 if ( other == Py_None ) return false;
4257 if ( ! wxGBPosition_helper(other, &obj) ) {
4258 PyErr_Clear();
4259 return false;
4260 }
4261 return self->operator==(*obj);
4262 }
4263 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4264 wxGBPosition temp, *obj = &temp;
4265 if ( other == Py_None ) return true;
4266 if ( ! wxGBPosition_helper(other, &obj)) {
4267 PyErr_Clear();
4268 return true;
4269 }
4270 return self->operator!=(*obj);
4271 }
4272 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4273 self->SetRow(row);
4274 self->SetCol(col);
4275 }
4276 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4278 PyObject* tup = PyTuple_New(2);
4279 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4280 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4281 wxPyEndBlockThreads(blocked);
4282 return tup;
4283 }
4284 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4285 wxGBSpan temp, *obj = &temp;
4286 if ( other == Py_None ) return false;
4287 if ( ! wxGBSpan_helper(other, &obj) ) {
4288 PyErr_Clear();
4289 return false;
4290 }
4291 return self->operator==(*obj);
4292 }
4293 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4294 wxGBSpan temp, *obj = &temp;
4295 if ( other == Py_None ) return true;
4296 if ( ! wxGBSpan_helper(other, &obj)) {
4297 PyErr_Clear();
4298 return true;
4299 }
4300 return self->operator!=(*obj);
4301 }
4302 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4303 self->SetRowspan(rowspan);
4304 self->SetColspan(colspan);
4305 }
4306 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 PyObject* tup = PyTuple_New(2);
4309 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4310 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4311 wxPyEndBlockThreads(blocked);
4312 return tup;
4313 }
4314 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4315 wxPyUserData* data = NULL;
4316 if ( userData ) {
4317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4318 data = new wxPyUserData(userData);
4319 wxPyEndBlockThreads(blocked);
4320 }
4321 return new wxGBSizerItem(window, pos, span, flag, border, data);
4322 }
4323 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4324 wxPyUserData* data = NULL;
4325 if ( userData ) {
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 data = new wxPyUserData(userData);
4328 wxPyEndBlockThreads(blocked);
4329 }
4330 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4331 }
4332 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4333 wxPyUserData* data = NULL;
4334 if ( userData ) {
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 data = new wxPyUserData(userData);
4337 wxPyEndBlockThreads(blocked);
4338 }
4339 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4340 }
4341 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4342 int row, col;
4343 self->GetEndPos(row, col);
4344 return wxGBPosition(row, col);
4345 }
4346 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4347
4348 wxPyUserData* data = NULL;
4349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4350 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4351 if ( userData && (info.window || info.sizer || info.gotSize) )
4352 data = new wxPyUserData(userData);
4353 if ( info.sizer )
4354 PyObject_SetAttrString(item,"thisown",Py_False);
4355 wxPyEndBlockThreads(blocked);
4356
4357 // Now call the real Add method if a valid item type was found
4358 if ( info.window )
4359 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4360 else if ( info.sizer )
4361 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4362 else if (info.gotSize)
4363 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4364 pos, span, flag, border, data);
4365 return NULL;
4366 }
4367
4368
4369 #ifdef __cplusplus
4370 extern "C" {
4371 #endif
4372 SWIGINTERN int EmptyString_set(PyObject *) {
4373 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4374 return 1;
4375 }
4376
4377
4378 SWIGINTERN PyObject *EmptyString_get(void) {
4379 PyObject *pyobj = 0;
4380
4381 {
4382 #if wxUSE_UNICODE
4383 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4384 #else
4385 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4386 #endif
4387 }
4388 return pyobj;
4389 }
4390
4391
4392 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4393 PyObject *resultobj = 0;
4394 wxObject *arg1 = (wxObject *) 0 ;
4395 wxString result;
4396 void *argp1 = 0 ;
4397 int res1 = 0 ;
4398 PyObject *swig_obj[1] ;
4399
4400 if (!args) SWIG_fail;
4401 swig_obj[0] = args;
4402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4403 if (!SWIG_IsOK(res1)) {
4404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4405 }
4406 arg1 = reinterpret_cast< wxObject * >(argp1);
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = wxObject_GetClassName(arg1);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 {
4414 #if wxUSE_UNICODE
4415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4416 #else
4417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4418 #endif
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4427 PyObject *resultobj = 0;
4428 wxObject *arg1 = (wxObject *) 0 ;
4429 void *argp1 = 0 ;
4430 int res1 = 0 ;
4431 PyObject *swig_obj[1] ;
4432
4433 if (!args) SWIG_fail;
4434 swig_obj[0] = args;
4435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4436 if (!SWIG_IsOK(res1)) {
4437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4438 }
4439 arg1 = reinterpret_cast< wxObject * >(argp1);
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 wxObject_Destroy(arg1);
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 resultobj = SWIG_Py_Void();
4447 return resultobj;
4448 fail:
4449 return NULL;
4450 }
4451
4452
4453 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4454 PyObject *obj;
4455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4456 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4457 return SWIG_Py_Void();
4458 }
4459
4460 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4461 PyObject *resultobj = 0;
4462 wxSize *arg1 = (wxSize *) 0 ;
4463 int arg2 ;
4464 void *argp1 = 0 ;
4465 int res1 = 0 ;
4466 int val2 ;
4467 int ecode2 = 0 ;
4468 PyObject *swig_obj[2] ;
4469
4470 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4472 if (!SWIG_IsOK(res1)) {
4473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4474 }
4475 arg1 = reinterpret_cast< wxSize * >(argp1);
4476 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4477 if (!SWIG_IsOK(ecode2)) {
4478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4479 }
4480 arg2 = static_cast< int >(val2);
4481 if (arg1) (arg1)->x = arg2;
4482
4483 resultobj = SWIG_Py_Void();
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxSize *arg1 = (wxSize *) 0 ;
4493 int result;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4503 }
4504 arg1 = reinterpret_cast< wxSize * >(argp1);
4505 result = (int) ((arg1)->x);
4506 resultobj = SWIG_From_int(static_cast< int >(result));
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 wxSize *arg1 = (wxSize *) 0 ;
4516 int arg2 ;
4517 void *argp1 = 0 ;
4518 int res1 = 0 ;
4519 int val2 ;
4520 int ecode2 = 0 ;
4521 PyObject *swig_obj[2] ;
4522
4523 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4525 if (!SWIG_IsOK(res1)) {
4526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4527 }
4528 arg1 = reinterpret_cast< wxSize * >(argp1);
4529 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4530 if (!SWIG_IsOK(ecode2)) {
4531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4532 }
4533 arg2 = static_cast< int >(val2);
4534 if (arg1) (arg1)->y = arg2;
4535
4536 resultobj = SWIG_Py_Void();
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4544 PyObject *resultobj = 0;
4545 wxSize *arg1 = (wxSize *) 0 ;
4546 int result;
4547 void *argp1 = 0 ;
4548 int res1 = 0 ;
4549 PyObject *swig_obj[1] ;
4550
4551 if (!args) SWIG_fail;
4552 swig_obj[0] = args;
4553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4554 if (!SWIG_IsOK(res1)) {
4555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4556 }
4557 arg1 = reinterpret_cast< wxSize * >(argp1);
4558 result = (int) ((arg1)->y);
4559 resultobj = SWIG_From_int(static_cast< int >(result));
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4567 PyObject *resultobj = 0;
4568 int arg1 = (int) 0 ;
4569 int arg2 = (int) 0 ;
4570 wxSize *result = 0 ;
4571 int val1 ;
4572 int ecode1 = 0 ;
4573 int val2 ;
4574 int ecode2 = 0 ;
4575 PyObject * obj0 = 0 ;
4576 PyObject * obj1 = 0 ;
4577 char * kwnames[] = {
4578 (char *) "w",(char *) "h", NULL
4579 };
4580
4581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4582 if (obj0) {
4583 ecode1 = SWIG_AsVal_int(obj0, &val1);
4584 if (!SWIG_IsOK(ecode1)) {
4585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4586 }
4587 arg1 = static_cast< int >(val1);
4588 }
4589 if (obj1) {
4590 ecode2 = SWIG_AsVal_int(obj1, &val2);
4591 if (!SWIG_IsOK(ecode2)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4593 }
4594 arg2 = static_cast< int >(val2);
4595 }
4596 {
4597 PyThreadState* __tstate = wxPyBeginAllowThreads();
4598 result = (wxSize *)new wxSize(arg1,arg2);
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4610 PyObject *resultobj = 0;
4611 wxSize *arg1 = (wxSize *) 0 ;
4612 void *argp1 = 0 ;
4613 int res1 = 0 ;
4614 PyObject *swig_obj[1] ;
4615
4616 if (!args) SWIG_fail;
4617 swig_obj[0] = args;
4618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4619 if (!SWIG_IsOK(res1)) {
4620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4621 }
4622 arg1 = reinterpret_cast< wxSize * >(argp1);
4623 {
4624 PyThreadState* __tstate = wxPyBeginAllowThreads();
4625 delete arg1;
4626
4627 wxPyEndAllowThreads(__tstate);
4628 if (PyErr_Occurred()) SWIG_fail;
4629 }
4630 resultobj = SWIG_Py_Void();
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj = 0;
4639 wxSize *arg1 = (wxSize *) 0 ;
4640 PyObject *arg2 = (PyObject *) 0 ;
4641 bool result;
4642 void *argp1 = 0 ;
4643 int res1 = 0 ;
4644 PyObject * obj0 = 0 ;
4645 PyObject * obj1 = 0 ;
4646 char * kwnames[] = {
4647 (char *) "self",(char *) "other", NULL
4648 };
4649
4650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4652 if (!SWIG_IsOK(res1)) {
4653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4654 }
4655 arg1 = reinterpret_cast< wxSize * >(argp1);
4656 arg2 = obj1;
4657 {
4658 result = (bool)wxSize___eq__(arg1,arg2);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4663 }
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 wxSize *arg1 = (wxSize *) 0 ;
4673 PyObject *arg2 = (PyObject *) 0 ;
4674 bool result;
4675 void *argp1 = 0 ;
4676 int res1 = 0 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 char * kwnames[] = {
4680 (char *) "self",(char *) "other", NULL
4681 };
4682
4683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4685 if (!SWIG_IsOK(res1)) {
4686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4687 }
4688 arg1 = reinterpret_cast< wxSize * >(argp1);
4689 arg2 = obj1;
4690 {
4691 result = (bool)wxSize___ne__(arg1,arg2);
4692 if (PyErr_Occurred()) SWIG_fail;
4693 }
4694 {
4695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4696 }
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4704 PyObject *resultobj = 0;
4705 wxSize *arg1 = (wxSize *) 0 ;
4706 wxSize *arg2 = 0 ;
4707 wxSize result;
4708 void *argp1 = 0 ;
4709 int res1 = 0 ;
4710 wxSize temp2 ;
4711 PyObject * obj0 = 0 ;
4712 PyObject * obj1 = 0 ;
4713 char * kwnames[] = {
4714 (char *) "self",(char *) "sz", NULL
4715 };
4716
4717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4719 if (!SWIG_IsOK(res1)) {
4720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4721 }
4722 arg1 = reinterpret_cast< wxSize * >(argp1);
4723 {
4724 arg2 = &temp2;
4725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (arg1)->operator +((wxSize const &)*arg2);
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = 0;
4742 wxSize *arg1 = (wxSize *) 0 ;
4743 wxSize *arg2 = 0 ;
4744 wxSize result;
4745 void *argp1 = 0 ;
4746 int res1 = 0 ;
4747 wxSize temp2 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "self",(char *) "sz", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4758 }
4759 arg1 = reinterpret_cast< wxSize * >(argp1);
4760 {
4761 arg2 = &temp2;
4762 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4763 }
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (arg1)->operator -((wxSize const &)*arg2);
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4778 PyObject *resultobj = 0;
4779 wxSize *arg1 = (wxSize *) 0 ;
4780 wxSize *arg2 = 0 ;
4781 void *argp1 = 0 ;
4782 int res1 = 0 ;
4783 wxSize temp2 ;
4784 PyObject * obj0 = 0 ;
4785 PyObject * obj1 = 0 ;
4786 char * kwnames[] = {
4787 (char *) "self",(char *) "sz", NULL
4788 };
4789
4790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4792 if (!SWIG_IsOK(res1)) {
4793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4794 }
4795 arg1 = reinterpret_cast< wxSize * >(argp1);
4796 {
4797 arg2 = &temp2;
4798 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4799 }
4800 {
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 (arg1)->IncTo((wxSize const &)*arg2);
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_Py_Void();
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj = 0;
4815 wxSize *arg1 = (wxSize *) 0 ;
4816 wxSize *arg2 = 0 ;
4817 void *argp1 = 0 ;
4818 int res1 = 0 ;
4819 wxSize temp2 ;
4820 PyObject * obj0 = 0 ;
4821 PyObject * obj1 = 0 ;
4822 char * kwnames[] = {
4823 (char *) "self",(char *) "sz", NULL
4824 };
4825
4826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4828 if (!SWIG_IsOK(res1)) {
4829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4830 }
4831 arg1 = reinterpret_cast< wxSize * >(argp1);
4832 {
4833 arg2 = &temp2;
4834 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4835 }
4836 {
4837 PyThreadState* __tstate = wxPyBeginAllowThreads();
4838 (arg1)->DecTo((wxSize const &)*arg2);
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 resultobj = SWIG_Py_Void();
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 wxSize *arg1 = (wxSize *) 0 ;
4852 int arg2 ;
4853 int arg3 ;
4854 void *argp1 = 0 ;
4855 int res1 = 0 ;
4856 int val2 ;
4857 int ecode2 = 0 ;
4858 int val3 ;
4859 int ecode3 = 0 ;
4860 PyObject * obj0 = 0 ;
4861 PyObject * obj1 = 0 ;
4862 PyObject * obj2 = 0 ;
4863 char * kwnames[] = {
4864 (char *) "self",(char *) "w",(char *) "h", NULL
4865 };
4866
4867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4869 if (!SWIG_IsOK(res1)) {
4870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4871 }
4872 arg1 = reinterpret_cast< wxSize * >(argp1);
4873 ecode2 = SWIG_AsVal_int(obj1, &val2);
4874 if (!SWIG_IsOK(ecode2)) {
4875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4876 }
4877 arg2 = static_cast< int >(val2);
4878 ecode3 = SWIG_AsVal_int(obj2, &val3);
4879 if (!SWIG_IsOK(ecode3)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4881 }
4882 arg3 = static_cast< int >(val3);
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 (arg1)->Set(arg2,arg3);
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 wxSize *arg1 = (wxSize *) 0 ;
4899 int arg2 ;
4900 void *argp1 = 0 ;
4901 int res1 = 0 ;
4902 int val2 ;
4903 int ecode2 = 0 ;
4904 PyObject * obj0 = 0 ;
4905 PyObject * obj1 = 0 ;
4906 char * kwnames[] = {
4907 (char *) "self",(char *) "w", NULL
4908 };
4909
4910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4912 if (!SWIG_IsOK(res1)) {
4913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4914 }
4915 arg1 = reinterpret_cast< wxSize * >(argp1);
4916 ecode2 = SWIG_AsVal_int(obj1, &val2);
4917 if (!SWIG_IsOK(ecode2)) {
4918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4919 }
4920 arg2 = static_cast< int >(val2);
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 (arg1)->SetWidth(arg2);
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 resultobj = SWIG_Py_Void();
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj = 0;
4936 wxSize *arg1 = (wxSize *) 0 ;
4937 int arg2 ;
4938 void *argp1 = 0 ;
4939 int res1 = 0 ;
4940 int val2 ;
4941 int ecode2 = 0 ;
4942 PyObject * obj0 = 0 ;
4943 PyObject * obj1 = 0 ;
4944 char * kwnames[] = {
4945 (char *) "self",(char *) "h", NULL
4946 };
4947
4948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4952 }
4953 arg1 = reinterpret_cast< wxSize * >(argp1);
4954 ecode2 = SWIG_AsVal_int(obj1, &val2);
4955 if (!SWIG_IsOK(ecode2)) {
4956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4957 }
4958 arg2 = static_cast< int >(val2);
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 (arg1)->SetHeight(arg2);
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 resultobj = SWIG_Py_Void();
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4973 PyObject *resultobj = 0;
4974 wxSize *arg1 = (wxSize *) 0 ;
4975 int result;
4976 void *argp1 = 0 ;
4977 int res1 = 0 ;
4978 PyObject *swig_obj[1] ;
4979
4980 if (!args) SWIG_fail;
4981 swig_obj[0] = args;
4982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 {
4988 PyThreadState* __tstate = wxPyBeginAllowThreads();
4989 result = (int)((wxSize const *)arg1)->GetWidth();
4990 wxPyEndAllowThreads(__tstate);
4991 if (PyErr_Occurred()) SWIG_fail;
4992 }
4993 resultobj = SWIG_From_int(static_cast< int >(result));
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002 wxSize *arg1 = (wxSize *) 0 ;
5003 int result;
5004 void *argp1 = 0 ;
5005 int res1 = 0 ;
5006 PyObject *swig_obj[1] ;
5007
5008 if (!args) SWIG_fail;
5009 swig_obj[0] = args;
5010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 {
5016 PyThreadState* __tstate = wxPyBeginAllowThreads();
5017 result = (int)((wxSize const *)arg1)->GetHeight();
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 resultobj = SWIG_From_int(static_cast< int >(result));
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5029 PyObject *resultobj = 0;
5030 wxSize *arg1 = (wxSize *) 0 ;
5031 bool result;
5032 void *argp1 = 0 ;
5033 int res1 = 0 ;
5034 PyObject *swig_obj[1] ;
5035
5036 if (!args) SWIG_fail;
5037 swig_obj[0] = args;
5038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5041 }
5042 arg1 = reinterpret_cast< wxSize * >(argp1);
5043 {
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 {
5050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5051 }
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj = 0;
5060 wxSize *arg1 = (wxSize *) 0 ;
5061 wxSize *arg2 = 0 ;
5062 void *argp1 = 0 ;
5063 int res1 = 0 ;
5064 wxSize temp2 ;
5065 PyObject * obj0 = 0 ;
5066 PyObject * obj1 = 0 ;
5067 char * kwnames[] = {
5068 (char *) "self",(char *) "size", NULL
5069 };
5070
5071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5075 }
5076 arg1 = reinterpret_cast< wxSize * >(argp1);
5077 {
5078 arg2 = &temp2;
5079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5080 }
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 (arg1)->SetDefaults((wxSize const &)*arg2);
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = SWIG_Py_Void();
5088 return resultobj;
5089 fail:
5090 return NULL;
5091 }
5092
5093
5094 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5095 PyObject *resultobj = 0;
5096 wxSize *arg1 = (wxSize *) 0 ;
5097 PyObject *result = 0 ;
5098 void *argp1 = 0 ;
5099 int res1 = 0 ;
5100 PyObject *swig_obj[1] ;
5101
5102 if (!args) SWIG_fail;
5103 swig_obj[0] = args;
5104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5105 if (!SWIG_IsOK(res1)) {
5106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5107 }
5108 arg1 = reinterpret_cast< wxSize * >(argp1);
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = (PyObject *)wxSize_Get(arg1);
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 resultobj = result;
5116 return resultobj;
5117 fail:
5118 return NULL;
5119 }
5120
5121
5122 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5123 PyObject *obj;
5124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5125 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5126 return SWIG_Py_Void();
5127 }
5128
5129 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5130 return SWIG_Python_InitShadowInstance(args);
5131 }
5132
5133 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5134 PyObject *resultobj = 0;
5135 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5136 double arg2 ;
5137 void *argp1 = 0 ;
5138 int res1 = 0 ;
5139 double val2 ;
5140 int ecode2 = 0 ;
5141 PyObject *swig_obj[2] ;
5142
5143 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5145 if (!SWIG_IsOK(res1)) {
5146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5147 }
5148 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5149 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5150 if (!SWIG_IsOK(ecode2)) {
5151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5152 }
5153 arg2 = static_cast< double >(val2);
5154 if (arg1) (arg1)->x = arg2;
5155
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5164 PyObject *resultobj = 0;
5165 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5166 double result;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 PyObject *swig_obj[1] ;
5170
5171 if (!args) SWIG_fail;
5172 swig_obj[0] = args;
5173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5176 }
5177 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5178 result = (double) ((arg1)->x);
5179 resultobj = SWIG_From_double(static_cast< double >(result));
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5187 PyObject *resultobj = 0;
5188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5189 double arg2 ;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 double val2 ;
5193 int ecode2 = 0 ;
5194 PyObject *swig_obj[2] ;
5195
5196 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5200 }
5201 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5202 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5203 if (!SWIG_IsOK(ecode2)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5205 }
5206 arg2 = static_cast< double >(val2);
5207 if (arg1) (arg1)->y = arg2;
5208
5209 resultobj = SWIG_Py_Void();
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5217 PyObject *resultobj = 0;
5218 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5219 double result;
5220 void *argp1 = 0 ;
5221 int res1 = 0 ;
5222 PyObject *swig_obj[1] ;
5223
5224 if (!args) SWIG_fail;
5225 swig_obj[0] = args;
5226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5227 if (!SWIG_IsOK(res1)) {
5228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5229 }
5230 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5231 result = (double) ((arg1)->y);
5232 resultobj = SWIG_From_double(static_cast< double >(result));
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5240 PyObject *resultobj = 0;
5241 double arg1 = (double) 0.0 ;
5242 double arg2 = (double) 0.0 ;
5243 wxRealPoint *result = 0 ;
5244 double val1 ;
5245 int ecode1 = 0 ;
5246 double val2 ;
5247 int ecode2 = 0 ;
5248 PyObject * obj0 = 0 ;
5249 PyObject * obj1 = 0 ;
5250 char * kwnames[] = {
5251 (char *) "x",(char *) "y", NULL
5252 };
5253
5254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5255 if (obj0) {
5256 ecode1 = SWIG_AsVal_double(obj0, &val1);
5257 if (!SWIG_IsOK(ecode1)) {
5258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5259 }
5260 arg1 = static_cast< double >(val1);
5261 }
5262 if (obj1) {
5263 ecode2 = SWIG_AsVal_double(obj1, &val2);
5264 if (!SWIG_IsOK(ecode2)) {
5265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5266 }
5267 arg2 = static_cast< double >(val2);
5268 }
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5283 PyObject *resultobj = 0;
5284 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5285 void *argp1 = 0 ;
5286 int res1 = 0 ;
5287 PyObject *swig_obj[1] ;
5288
5289 if (!args) SWIG_fail;
5290 swig_obj[0] = args;
5291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5292 if (!SWIG_IsOK(res1)) {
5293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5294 }
5295 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5296 {
5297 PyThreadState* __tstate = wxPyBeginAllowThreads();
5298 delete arg1;
5299
5300 wxPyEndAllowThreads(__tstate);
5301 if (PyErr_Occurred()) SWIG_fail;
5302 }
5303 resultobj = SWIG_Py_Void();
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj = 0;
5312 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5313 PyObject *arg2 = (PyObject *) 0 ;
5314 bool result;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 char * kwnames[] = {
5320 (char *) "self",(char *) "other", NULL
5321 };
5322
5323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5325 if (!SWIG_IsOK(res1)) {
5326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5327 }
5328 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5329 arg2 = obj1;
5330 {
5331 result = (bool)wxRealPoint___eq__(arg1,arg2);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 {
5335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5336 }
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj = 0;
5345 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5346 PyObject *arg2 = (PyObject *) 0 ;
5347 bool result;
5348 void *argp1 = 0 ;
5349 int res1 = 0 ;
5350 PyObject * obj0 = 0 ;
5351 PyObject * obj1 = 0 ;
5352 char * kwnames[] = {
5353 (char *) "self",(char *) "other", NULL
5354 };
5355
5356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5358 if (!SWIG_IsOK(res1)) {
5359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5360 }
5361 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5362 arg2 = obj1;
5363 {
5364 result = (bool)wxRealPoint___ne__(arg1,arg2);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5369 }
5370 return resultobj;
5371 fail:
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5377 PyObject *resultobj = 0;
5378 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5379 wxRealPoint *arg2 = 0 ;
5380 wxRealPoint result;
5381 void *argp1 = 0 ;
5382 int res1 = 0 ;
5383 wxRealPoint temp2 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char * kwnames[] = {
5387 (char *) "self",(char *) "pt", NULL
5388 };
5389
5390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5392 if (!SWIG_IsOK(res1)) {
5393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5394 }
5395 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5396 {
5397 arg2 = &temp2;
5398 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5399 }
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5403 wxPyEndAllowThreads(__tstate);
5404 if (PyErr_Occurred()) SWIG_fail;
5405 }
5406 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5407 return resultobj;
5408 fail:
5409 return NULL;
5410 }
5411
5412
5413 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj = 0;
5415 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5416 wxRealPoint *arg2 = 0 ;
5417 wxRealPoint result;
5418 void *argp1 = 0 ;
5419 int res1 = 0 ;
5420 wxRealPoint temp2 ;
5421 PyObject * obj0 = 0 ;
5422 PyObject * obj1 = 0 ;
5423 char * kwnames[] = {
5424 (char *) "self",(char *) "pt", NULL
5425 };
5426
5427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5429 if (!SWIG_IsOK(res1)) {
5430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5431 }
5432 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5433 {
5434 arg2 = &temp2;
5435 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5436 }
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj = 0;
5452 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5453 double arg2 ;
5454 double arg3 ;
5455 void *argp1 = 0 ;
5456 int res1 = 0 ;
5457 double val2 ;
5458 int ecode2 = 0 ;
5459 double val3 ;
5460 int ecode3 = 0 ;
5461 PyObject * obj0 = 0 ;
5462 PyObject * obj1 = 0 ;
5463 PyObject * obj2 = 0 ;
5464 char * kwnames[] = {
5465 (char *) "self",(char *) "x",(char *) "y", NULL
5466 };
5467
5468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5470 if (!SWIG_IsOK(res1)) {
5471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5472 }
5473 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5474 ecode2 = SWIG_AsVal_double(obj1, &val2);
5475 if (!SWIG_IsOK(ecode2)) {
5476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5477 }
5478 arg2 = static_cast< double >(val2);
5479 ecode3 = SWIG_AsVal_double(obj2, &val3);
5480 if (!SWIG_IsOK(ecode3)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5482 }
5483 arg3 = static_cast< double >(val3);
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 wxRealPoint_Set(arg1,arg2,arg3);
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = SWIG_Py_Void();
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5498 PyObject *resultobj = 0;
5499 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5500 PyObject *result = 0 ;
5501 void *argp1 = 0 ;
5502 int res1 = 0 ;
5503 PyObject *swig_obj[1] ;
5504
5505 if (!args) SWIG_fail;
5506 swig_obj[0] = args;
5507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5508 if (!SWIG_IsOK(res1)) {
5509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5510 }
5511 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = (PyObject *)wxRealPoint_Get(arg1);
5515 wxPyEndAllowThreads(__tstate);
5516 if (PyErr_Occurred()) SWIG_fail;
5517 }
5518 resultobj = result;
5519 return resultobj;
5520 fail:
5521 return NULL;
5522 }
5523
5524
5525 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *obj;
5527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5528 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5529 return SWIG_Py_Void();
5530 }
5531
5532 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 return SWIG_Python_InitShadowInstance(args);
5534 }
5535
5536 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5537 PyObject *resultobj = 0;
5538 wxPoint *arg1 = (wxPoint *) 0 ;
5539 int arg2 ;
5540 void *argp1 = 0 ;
5541 int res1 = 0 ;
5542 int val2 ;
5543 int ecode2 = 0 ;
5544 PyObject *swig_obj[2] ;
5545
5546 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5548 if (!SWIG_IsOK(res1)) {
5549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5550 }
5551 arg1 = reinterpret_cast< wxPoint * >(argp1);
5552 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5553 if (!SWIG_IsOK(ecode2)) {
5554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5555 }
5556 arg2 = static_cast< int >(val2);
5557 if (arg1) (arg1)->x = arg2;
5558
5559 resultobj = SWIG_Py_Void();
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *resultobj = 0;
5568 wxPoint *arg1 = (wxPoint *) 0 ;
5569 int result;
5570 void *argp1 = 0 ;
5571 int res1 = 0 ;
5572 PyObject *swig_obj[1] ;
5573
5574 if (!args) SWIG_fail;
5575 swig_obj[0] = args;
5576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5577 if (!SWIG_IsOK(res1)) {
5578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5579 }
5580 arg1 = reinterpret_cast< wxPoint * >(argp1);
5581 result = (int) ((arg1)->x);
5582 resultobj = SWIG_From_int(static_cast< int >(result));
5583 return resultobj;
5584 fail:
5585 return NULL;
5586 }
5587
5588
5589 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5590 PyObject *resultobj = 0;
5591 wxPoint *arg1 = (wxPoint *) 0 ;
5592 int arg2 ;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 int val2 ;
5596 int ecode2 = 0 ;
5597 PyObject *swig_obj[2] ;
5598
5599 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5601 if (!SWIG_IsOK(res1)) {
5602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5603 }
5604 arg1 = reinterpret_cast< wxPoint * >(argp1);
5605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5606 if (!SWIG_IsOK(ecode2)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5608 }
5609 arg2 = static_cast< int >(val2);
5610 if (arg1) (arg1)->y = arg2;
5611
5612 resultobj = SWIG_Py_Void();
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5620 PyObject *resultobj = 0;
5621 wxPoint *arg1 = (wxPoint *) 0 ;
5622 int result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 PyObject *swig_obj[1] ;
5626
5627 if (!args) SWIG_fail;
5628 swig_obj[0] = args;
5629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5630 if (!SWIG_IsOK(res1)) {
5631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5632 }
5633 arg1 = reinterpret_cast< wxPoint * >(argp1);
5634 result = (int) ((arg1)->y);
5635 resultobj = SWIG_From_int(static_cast< int >(result));
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = 0;
5644 int arg1 = (int) 0 ;
5645 int arg2 = (int) 0 ;
5646 wxPoint *result = 0 ;
5647 int val1 ;
5648 int ecode1 = 0 ;
5649 int val2 ;
5650 int ecode2 = 0 ;
5651 PyObject * obj0 = 0 ;
5652 PyObject * obj1 = 0 ;
5653 char * kwnames[] = {
5654 (char *) "x",(char *) "y", NULL
5655 };
5656
5657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5658 if (obj0) {
5659 ecode1 = SWIG_AsVal_int(obj0, &val1);
5660 if (!SWIG_IsOK(ecode1)) {
5661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5662 }
5663 arg1 = static_cast< int >(val1);
5664 }
5665 if (obj1) {
5666 ecode2 = SWIG_AsVal_int(obj1, &val2);
5667 if (!SWIG_IsOK(ecode2)) {
5668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5669 }
5670 arg2 = static_cast< int >(val2);
5671 }
5672 {
5673 PyThreadState* __tstate = wxPyBeginAllowThreads();
5674 result = (wxPoint *)new wxPoint(arg1,arg2);
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5686 PyObject *resultobj = 0;
5687 wxPoint *arg1 = (wxPoint *) 0 ;
5688 void *argp1 = 0 ;
5689 int res1 = 0 ;
5690 PyObject *swig_obj[1] ;
5691
5692 if (!args) SWIG_fail;
5693 swig_obj[0] = args;
5694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5695 if (!SWIG_IsOK(res1)) {
5696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5697 }
5698 arg1 = reinterpret_cast< wxPoint * >(argp1);
5699 {
5700 PyThreadState* __tstate = wxPyBeginAllowThreads();
5701 delete arg1;
5702
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = SWIG_Py_Void();
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj = 0;
5715 wxPoint *arg1 = (wxPoint *) 0 ;
5716 PyObject *arg2 = (PyObject *) 0 ;
5717 bool result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 PyObject * obj0 = 0 ;
5721 PyObject * obj1 = 0 ;
5722 char * kwnames[] = {
5723 (char *) "self",(char *) "other", NULL
5724 };
5725
5726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5728 if (!SWIG_IsOK(res1)) {
5729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5730 }
5731 arg1 = reinterpret_cast< wxPoint * >(argp1);
5732 arg2 = obj1;
5733 {
5734 result = (bool)wxPoint___eq__(arg1,arg2);
5735 if (PyErr_Occurred()) SWIG_fail;
5736 }
5737 {
5738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5739 }
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
5746 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj = 0;
5748 wxPoint *arg1 = (wxPoint *) 0 ;
5749 PyObject *arg2 = (PyObject *) 0 ;
5750 bool result;
5751 void *argp1 = 0 ;
5752 int res1 = 0 ;
5753 PyObject * obj0 = 0 ;
5754 PyObject * obj1 = 0 ;
5755 char * kwnames[] = {
5756 (char *) "self",(char *) "other", NULL
5757 };
5758
5759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5761 if (!SWIG_IsOK(res1)) {
5762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5763 }
5764 arg1 = reinterpret_cast< wxPoint * >(argp1);
5765 arg2 = obj1;
5766 {
5767 result = (bool)wxPoint___ne__(arg1,arg2);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 {
5771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5772 }
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj = 0;
5781 wxPoint *arg1 = (wxPoint *) 0 ;
5782 wxPoint *arg2 = 0 ;
5783 wxPoint result;
5784 void *argp1 = 0 ;
5785 int res1 = 0 ;
5786 wxPoint temp2 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "pt", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxPoint * >(argp1);
5799 {
5800 arg2 = &temp2;
5801 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5802 }
5803 {
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 result = (arg1)->operator +((wxPoint const &)*arg2);
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj = 0;
5818 wxPoint *arg1 = (wxPoint *) 0 ;
5819 wxPoint *arg2 = 0 ;
5820 wxPoint result;
5821 void *argp1 = 0 ;
5822 int res1 = 0 ;
5823 wxPoint temp2 ;
5824 PyObject * obj0 = 0 ;
5825 PyObject * obj1 = 0 ;
5826 char * kwnames[] = {
5827 (char *) "self",(char *) "pt", NULL
5828 };
5829
5830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5832 if (!SWIG_IsOK(res1)) {
5833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5834 }
5835 arg1 = reinterpret_cast< wxPoint * >(argp1);
5836 {
5837 arg2 = &temp2;
5838 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 result = (arg1)->operator -((wxPoint const &)*arg2);
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj = 0;
5855 wxPoint *arg1 = (wxPoint *) 0 ;
5856 wxPoint *arg2 = 0 ;
5857 wxPoint *result = 0 ;
5858 void *argp1 = 0 ;
5859 int res1 = 0 ;
5860 wxPoint temp2 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char * kwnames[] = {
5864 (char *) "self",(char *) "pt", NULL
5865 };
5866
5867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5869 if (!SWIG_IsOK(res1)) {
5870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5871 }
5872 arg1 = reinterpret_cast< wxPoint * >(argp1);
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 {
5880 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5881 result = (wxPoint *) &_result_ref;
5882 }
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj = 0;
5895 wxPoint *arg1 = (wxPoint *) 0 ;
5896 wxPoint *arg2 = 0 ;
5897 wxPoint *result = 0 ;
5898 void *argp1 = 0 ;
5899 int res1 = 0 ;
5900 wxPoint temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char * kwnames[] = {
5904 (char *) "self",(char *) "pt", NULL
5905 };
5906
5907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5909 if (!SWIG_IsOK(res1)) {
5910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5911 }
5912 arg1 = reinterpret_cast< wxPoint * >(argp1);
5913 {
5914 arg2 = &temp2;
5915 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5916 }
5917 {
5918 PyThreadState* __tstate = wxPyBeginAllowThreads();
5919 {
5920 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5921 result = (wxPoint *) &_result_ref;
5922 }
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5927 return resultobj;
5928 fail:
5929 return NULL;
5930 }
5931
5932
5933 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5934 PyObject *resultobj = 0;
5935 wxPoint *arg1 = (wxPoint *) 0 ;
5936 long arg2 ;
5937 long arg3 ;
5938 void *argp1 = 0 ;
5939 int res1 = 0 ;
5940 long val2 ;
5941 int ecode2 = 0 ;
5942 long val3 ;
5943 int ecode3 = 0 ;
5944 PyObject * obj0 = 0 ;
5945 PyObject * obj1 = 0 ;
5946 PyObject * obj2 = 0 ;
5947 char * kwnames[] = {
5948 (char *) "self",(char *) "x",(char *) "y", NULL
5949 };
5950
5951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5953 if (!SWIG_IsOK(res1)) {
5954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5955 }
5956 arg1 = reinterpret_cast< wxPoint * >(argp1);
5957 ecode2 = SWIG_AsVal_long(obj1, &val2);
5958 if (!SWIG_IsOK(ecode2)) {
5959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5960 }
5961 arg2 = static_cast< long >(val2);
5962 ecode3 = SWIG_AsVal_long(obj2, &val3);
5963 if (!SWIG_IsOK(ecode3)) {
5964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5965 }
5966 arg3 = static_cast< long >(val3);
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 wxPoint_Set(arg1,arg2,arg3);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_Py_Void();
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 PyObject *result = 0 ;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 PyObject *swig_obj[1] ;
5987
5988 if (!args) SWIG_fail;
5989 swig_obj[0] = args;
5990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5991 if (!SWIG_IsOK(res1)) {
5992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5993 }
5994 arg1 = reinterpret_cast< wxPoint * >(argp1);
5995 {
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 result = (PyObject *)wxPoint_Get(arg1);
5998 wxPyEndAllowThreads(__tstate);
5999 if (PyErr_Occurred()) SWIG_fail;
6000 }
6001 resultobj = result;
6002 return resultobj;
6003 fail:
6004 return NULL;
6005 }
6006
6007
6008 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6009 PyObject *obj;
6010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6011 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6012 return SWIG_Py_Void();
6013 }
6014
6015 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6016 return SWIG_Python_InitShadowInstance(args);
6017 }
6018
6019 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj = 0;
6021 int arg1 = (int) 0 ;
6022 int arg2 = (int) 0 ;
6023 int arg3 = (int) 0 ;
6024 int arg4 = (int) 0 ;
6025 wxRect *result = 0 ;
6026 int val1 ;
6027 int ecode1 = 0 ;
6028 int val2 ;
6029 int ecode2 = 0 ;
6030 int val3 ;
6031 int ecode3 = 0 ;
6032 int val4 ;
6033 int ecode4 = 0 ;
6034 PyObject * obj0 = 0 ;
6035 PyObject * obj1 = 0 ;
6036 PyObject * obj2 = 0 ;
6037 PyObject * obj3 = 0 ;
6038 char * kwnames[] = {
6039 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6040 };
6041
6042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6043 if (obj0) {
6044 ecode1 = SWIG_AsVal_int(obj0, &val1);
6045 if (!SWIG_IsOK(ecode1)) {
6046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6047 }
6048 arg1 = static_cast< int >(val1);
6049 }
6050 if (obj1) {
6051 ecode2 = SWIG_AsVal_int(obj1, &val2);
6052 if (!SWIG_IsOK(ecode2)) {
6053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6054 }
6055 arg2 = static_cast< int >(val2);
6056 }
6057 if (obj2) {
6058 ecode3 = SWIG_AsVal_int(obj2, &val3);
6059 if (!SWIG_IsOK(ecode3)) {
6060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6061 }
6062 arg3 = static_cast< int >(val3);
6063 }
6064 if (obj3) {
6065 ecode4 = SWIG_AsVal_int(obj3, &val4);
6066 if (!SWIG_IsOK(ecode4)) {
6067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6068 }
6069 arg4 = static_cast< int >(val4);
6070 }
6071 {
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj = 0;
6086 wxPoint *arg1 = 0 ;
6087 wxPoint *arg2 = 0 ;
6088 wxRect *result = 0 ;
6089 wxPoint temp1 ;
6090 wxPoint temp2 ;
6091 PyObject * obj0 = 0 ;
6092 PyObject * obj1 = 0 ;
6093 char * kwnames[] = {
6094 (char *) "topLeft",(char *) "bottomRight", NULL
6095 };
6096
6097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6098 {
6099 arg1 = &temp1;
6100 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6101 }
6102 {
6103 arg2 = &temp2;
6104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6105 }
6106 {
6107 PyThreadState* __tstate = wxPyBeginAllowThreads();
6108 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6109 wxPyEndAllowThreads(__tstate);
6110 if (PyErr_Occurred()) SWIG_fail;
6111 }
6112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6113 return resultobj;
6114 fail:
6115 return NULL;
6116 }
6117
6118
6119 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6120 PyObject *resultobj = 0;
6121 wxPoint *arg1 = 0 ;
6122 wxSize *arg2 = 0 ;
6123 wxRect *result = 0 ;
6124 wxPoint temp1 ;
6125 wxSize temp2 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char * kwnames[] = {
6129 (char *) "pos",(char *) "size", NULL
6130 };
6131
6132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6133 {
6134 arg1 = &temp1;
6135 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6136 }
6137 {
6138 arg2 = &temp2;
6139 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6140 }
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6155 PyObject *resultobj = 0;
6156 wxSize *arg1 = 0 ;
6157 wxRect *result = 0 ;
6158 wxSize temp1 ;
6159 PyObject * obj0 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "size", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6183 PyObject *resultobj = 0;
6184 wxRect *arg1 = (wxRect *) 0 ;
6185 void *argp1 = 0 ;
6186 int res1 = 0 ;
6187 PyObject *swig_obj[1] ;
6188
6189 if (!args) SWIG_fail;
6190 swig_obj[0] = args;
6191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6192 if (!SWIG_IsOK(res1)) {
6193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6194 }
6195 arg1 = reinterpret_cast< wxRect * >(argp1);
6196 {
6197 PyThreadState* __tstate = wxPyBeginAllowThreads();
6198 delete arg1;
6199
6200 wxPyEndAllowThreads(__tstate);
6201 if (PyErr_Occurred()) SWIG_fail;
6202 }
6203 resultobj = SWIG_Py_Void();
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6211 PyObject *resultobj = 0;
6212 wxRect *arg1 = (wxRect *) 0 ;
6213 int result;
6214 void *argp1 = 0 ;
6215 int res1 = 0 ;
6216 PyObject *swig_obj[1] ;
6217
6218 if (!args) SWIG_fail;
6219 swig_obj[0] = args;
6220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6221 if (!SWIG_IsOK(res1)) {
6222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6223 }
6224 arg1 = reinterpret_cast< wxRect * >(argp1);
6225 {
6226 PyThreadState* __tstate = wxPyBeginAllowThreads();
6227 result = (int)((wxRect const *)arg1)->GetX();
6228 wxPyEndAllowThreads(__tstate);
6229 if (PyErr_Occurred()) SWIG_fail;
6230 }
6231 resultobj = SWIG_From_int(static_cast< int >(result));
6232 return resultobj;
6233 fail:
6234 return NULL;
6235 }
6236
6237
6238 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6239 PyObject *resultobj = 0;
6240 wxRect *arg1 = (wxRect *) 0 ;
6241 int arg2 ;
6242 void *argp1 = 0 ;
6243 int res1 = 0 ;
6244 int val2 ;
6245 int ecode2 = 0 ;
6246 PyObject * obj0 = 0 ;
6247 PyObject * obj1 = 0 ;
6248 char * kwnames[] = {
6249 (char *) "self",(char *) "x", NULL
6250 };
6251
6252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6256 }
6257 arg1 = reinterpret_cast< wxRect * >(argp1);
6258 ecode2 = SWIG_AsVal_int(obj1, &val2);
6259 if (!SWIG_IsOK(ecode2)) {
6260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6261 }
6262 arg2 = static_cast< int >(val2);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 (arg1)->SetX(arg2);
6266 wxPyEndAllowThreads(__tstate);
6267 if (PyErr_Occurred()) SWIG_fail;
6268 }
6269 resultobj = SWIG_Py_Void();
6270 return resultobj;
6271 fail:
6272 return NULL;
6273 }
6274
6275
6276 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6277 PyObject *resultobj = 0;
6278 wxRect *arg1 = (wxRect *) 0 ;
6279 int result;
6280 void *argp1 = 0 ;
6281 int res1 = 0 ;
6282 PyObject *swig_obj[1] ;
6283
6284 if (!args) SWIG_fail;
6285 swig_obj[0] = args;
6286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6287 if (!SWIG_IsOK(res1)) {
6288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6289 }
6290 arg1 = reinterpret_cast< wxRect * >(argp1);
6291 {
6292 PyThreadState* __tstate = wxPyBeginAllowThreads();
6293 result = (int)(arg1)->GetY();
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 resultobj = SWIG_From_int(static_cast< int >(result));
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = 0;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int arg2 ;
6308 void *argp1 = 0 ;
6309 int res1 = 0 ;
6310 int val2 ;
6311 int ecode2 = 0 ;
6312 PyObject * obj0 = 0 ;
6313 PyObject * obj1 = 0 ;
6314 char * kwnames[] = {
6315 (char *) "self",(char *) "y", NULL
6316 };
6317
6318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6320 if (!SWIG_IsOK(res1)) {
6321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6322 }
6323 arg1 = reinterpret_cast< wxRect * >(argp1);
6324 ecode2 = SWIG_AsVal_int(obj1, &val2);
6325 if (!SWIG_IsOK(ecode2)) {
6326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6327 }
6328 arg2 = static_cast< int >(val2);
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 (arg1)->SetY(arg2);
6332 wxPyEndAllowThreads(__tstate);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 resultobj = SWIG_Py_Void();
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6343 PyObject *resultobj = 0;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 int result;
6346 void *argp1 = 0 ;
6347 int res1 = 0 ;
6348 PyObject *swig_obj[1] ;
6349
6350 if (!args) SWIG_fail;
6351 swig_obj[0] = args;
6352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6353 if (!SWIG_IsOK(res1)) {
6354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6355 }
6356 arg1 = reinterpret_cast< wxRect * >(argp1);
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (int)((wxRect const *)arg1)->GetWidth();
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 resultobj = SWIG_From_int(static_cast< int >(result));
6364 return resultobj;
6365 fail:
6366 return NULL;
6367 }
6368
6369
6370 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6371 PyObject *resultobj = 0;
6372 wxRect *arg1 = (wxRect *) 0 ;
6373 int arg2 ;
6374 void *argp1 = 0 ;
6375 int res1 = 0 ;
6376 int val2 ;
6377 int ecode2 = 0 ;
6378 PyObject * obj0 = 0 ;
6379 PyObject * obj1 = 0 ;
6380 char * kwnames[] = {
6381 (char *) "self",(char *) "w", NULL
6382 };
6383
6384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6386 if (!SWIG_IsOK(res1)) {
6387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6388 }
6389 arg1 = reinterpret_cast< wxRect * >(argp1);
6390 ecode2 = SWIG_AsVal_int(obj1, &val2);
6391 if (!SWIG_IsOK(ecode2)) {
6392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6393 }
6394 arg2 = static_cast< int >(val2);
6395 {
6396 PyThreadState* __tstate = wxPyBeginAllowThreads();
6397 (arg1)->SetWidth(arg2);
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 resultobj = SWIG_Py_Void();
6402 return resultobj;
6403 fail:
6404 return NULL;
6405 }
6406
6407
6408 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6409 PyObject *resultobj = 0;
6410 wxRect *arg1 = (wxRect *) 0 ;
6411 int result;
6412 void *argp1 = 0 ;
6413 int res1 = 0 ;
6414 PyObject *swig_obj[1] ;
6415
6416 if (!args) SWIG_fail;
6417 swig_obj[0] = args;
6418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6419 if (!SWIG_IsOK(res1)) {
6420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6421 }
6422 arg1 = reinterpret_cast< wxRect * >(argp1);
6423 {
6424 PyThreadState* __tstate = wxPyBeginAllowThreads();
6425 result = (int)((wxRect const *)arg1)->GetHeight();
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = SWIG_From_int(static_cast< int >(result));
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj = 0;
6438 wxRect *arg1 = (wxRect *) 0 ;
6439 int arg2 ;
6440 void *argp1 = 0 ;
6441 int res1 = 0 ;
6442 int val2 ;
6443 int ecode2 = 0 ;
6444 PyObject * obj0 = 0 ;
6445 PyObject * obj1 = 0 ;
6446 char * kwnames[] = {
6447 (char *) "self",(char *) "h", NULL
6448 };
6449
6450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6452 if (!SWIG_IsOK(res1)) {
6453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6454 }
6455 arg1 = reinterpret_cast< wxRect * >(argp1);
6456 ecode2 = SWIG_AsVal_int(obj1, &val2);
6457 if (!SWIG_IsOK(ecode2)) {
6458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6459 }
6460 arg2 = static_cast< int >(val2);
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 (arg1)->SetHeight(arg2);
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_Py_Void();
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6475 PyObject *resultobj = 0;
6476 wxRect *arg1 = (wxRect *) 0 ;
6477 wxPoint result;
6478 void *argp1 = 0 ;
6479 int res1 = 0 ;
6480 PyObject *swig_obj[1] ;
6481
6482 if (!args) SWIG_fail;
6483 swig_obj[0] = args;
6484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6485 if (!SWIG_IsOK(res1)) {
6486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6487 }
6488 arg1 = reinterpret_cast< wxRect * >(argp1);
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = ((wxRect const *)arg1)->GetPosition();
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj = 0;
6504 wxRect *arg1 = (wxRect *) 0 ;
6505 wxPoint *arg2 = 0 ;
6506 void *argp1 = 0 ;
6507 int res1 = 0 ;
6508 wxPoint temp2 ;
6509 PyObject * obj0 = 0 ;
6510 PyObject * obj1 = 0 ;
6511 char * kwnames[] = {
6512 (char *) "self",(char *) "p", NULL
6513 };
6514
6515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6519 }
6520 arg1 = reinterpret_cast< wxRect * >(argp1);
6521 {
6522 arg2 = &temp2;
6523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6524 }
6525 {
6526 PyThreadState* __tstate = wxPyBeginAllowThreads();
6527 (arg1)->SetPosition((wxPoint const &)*arg2);
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_Py_Void();
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 wxSize result;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 PyObject *swig_obj[1] ;
6545
6546 if (!args) SWIG_fail;
6547 swig_obj[0] = args;
6548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6551 }
6552 arg1 = reinterpret_cast< wxRect * >(argp1);
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 result = ((wxRect const *)arg1)->GetSize();
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6560 return resultobj;
6561 fail:
6562 return NULL;
6563 }
6564
6565
6566 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6567 PyObject *resultobj = 0;
6568 wxRect *arg1 = (wxRect *) 0 ;
6569 wxSize *arg2 = 0 ;
6570 void *argp1 = 0 ;
6571 int res1 = 0 ;
6572 wxSize temp2 ;
6573 PyObject * obj0 = 0 ;
6574 PyObject * obj1 = 0 ;
6575 char * kwnames[] = {
6576 (char *) "self",(char *) "s", NULL
6577 };
6578
6579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 arg2 = &temp2;
6587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6588 }
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 (arg1)->SetSize((wxSize const &)*arg2);
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 resultobj = SWIG_Py_Void();
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6603 PyObject *resultobj = 0;
6604 wxRect *arg1 = (wxRect *) 0 ;
6605 bool result;
6606 void *argp1 = 0 ;
6607 int res1 = 0 ;
6608 PyObject *swig_obj[1] ;
6609
6610 if (!args) SWIG_fail;
6611 swig_obj[0] = args;
6612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6615 }
6616 arg1 = reinterpret_cast< wxRect * >(argp1);
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = (bool)((wxRect const *)arg1)->IsEmpty();
6620 wxPyEndAllowThreads(__tstate);
6621 if (PyErr_Occurred()) SWIG_fail;
6622 }
6623 {
6624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6625 }
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 wxPoint result;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 PyObject *swig_obj[1] ;
6639
6640 if (!args) SWIG_fail;
6641 swig_obj[0] = args;
6642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6643 if (!SWIG_IsOK(res1)) {
6644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6645 }
6646 arg1 = reinterpret_cast< wxRect * >(argp1);
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 result = ((wxRect const *)arg1)->GetTopLeft();
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj = 0;
6662 wxRect *arg1 = (wxRect *) 0 ;
6663 wxPoint *arg2 = 0 ;
6664 void *argp1 = 0 ;
6665 int res1 = 0 ;
6666 wxPoint temp2 ;
6667 PyObject * obj0 = 0 ;
6668 PyObject * obj1 = 0 ;
6669 char * kwnames[] = {
6670 (char *) "self",(char *) "p", NULL
6671 };
6672
6673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6675 if (!SWIG_IsOK(res1)) {
6676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6677 }
6678 arg1 = reinterpret_cast< wxRect * >(argp1);
6679 {
6680 arg2 = &temp2;
6681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6682 }
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_Py_Void();
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxPoint result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 result = ((wxRect const *)arg1)->GetBottomRight();
6714 wxPyEndAllowThreads(__tstate);
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj = 0;
6726 wxRect *arg1 = (wxRect *) 0 ;
6727 wxPoint *arg2 = 0 ;
6728 void *argp1 = 0 ;
6729 int res1 = 0 ;
6730 wxPoint temp2 ;
6731 PyObject * obj0 = 0 ;
6732 PyObject * obj1 = 0 ;
6733 char * kwnames[] = {
6734 (char *) "self",(char *) "p", NULL
6735 };
6736
6737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6739 if (!SWIG_IsOK(res1)) {
6740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6741 }
6742 arg1 = reinterpret_cast< wxRect * >(argp1);
6743 {
6744 arg2 = &temp2;
6745 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6746 }
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 resultobj = SWIG_Py_Void();
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxRect *arg1 = (wxRect *) 0 ;
6763 int result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6773 }
6774 arg1 = reinterpret_cast< wxRect * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (int)((wxRect const *)arg1)->GetLeft();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_From_int(static_cast< int >(result));
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6789 PyObject *resultobj = 0;
6790 wxRect *arg1 = (wxRect *) 0 ;
6791 int result;
6792 void *argp1 = 0 ;
6793 int res1 = 0 ;
6794 PyObject *swig_obj[1] ;
6795
6796 if (!args) SWIG_fail;
6797 swig_obj[0] = args;
6798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6799 if (!SWIG_IsOK(res1)) {
6800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6801 }
6802 arg1 = reinterpret_cast< wxRect * >(argp1);
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 result = (int)((wxRect const *)arg1)->GetTop();
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_From_int(static_cast< int >(result));
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6817 PyObject *resultobj = 0;
6818 wxRect *arg1 = (wxRect *) 0 ;
6819 int result;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 PyObject *swig_obj[1] ;
6823
6824 if (!args) SWIG_fail;
6825 swig_obj[0] = args;
6826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6827 if (!SWIG_IsOK(res1)) {
6828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6829 }
6830 arg1 = reinterpret_cast< wxRect * >(argp1);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (int)((wxRect const *)arg1)->GetBottom();
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_From_int(static_cast< int >(result));
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 int result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 result = (int)((wxRect const *)arg1)->GetRight();
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 resultobj = SWIG_From_int(static_cast< int >(result));
6866 return resultobj;
6867 fail:
6868 return NULL;
6869 }
6870
6871
6872 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6873 PyObject *resultobj = 0;
6874 wxRect *arg1 = (wxRect *) 0 ;
6875 int arg2 ;
6876 void *argp1 = 0 ;
6877 int res1 = 0 ;
6878 int val2 ;
6879 int ecode2 = 0 ;
6880 PyObject * obj0 = 0 ;
6881 PyObject * obj1 = 0 ;
6882 char * kwnames[] = {
6883 (char *) "self",(char *) "left", NULL
6884 };
6885
6886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6888 if (!SWIG_IsOK(res1)) {
6889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6890 }
6891 arg1 = reinterpret_cast< wxRect * >(argp1);
6892 ecode2 = SWIG_AsVal_int(obj1, &val2);
6893 if (!SWIG_IsOK(ecode2)) {
6894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6895 }
6896 arg2 = static_cast< int >(val2);
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 (arg1)->SetLeft(arg2);
6900 wxPyEndAllowThreads(__tstate);
6901 if (PyErr_Occurred()) SWIG_fail;
6902 }
6903 resultobj = SWIG_Py_Void();
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj = 0;
6912 wxRect *arg1 = (wxRect *) 0 ;
6913 int arg2 ;
6914 void *argp1 = 0 ;
6915 int res1 = 0 ;
6916 int val2 ;
6917 int ecode2 = 0 ;
6918 PyObject * obj0 = 0 ;
6919 PyObject * obj1 = 0 ;
6920 char * kwnames[] = {
6921 (char *) "self",(char *) "right", NULL
6922 };
6923
6924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6926 if (!SWIG_IsOK(res1)) {
6927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6928 }
6929 arg1 = reinterpret_cast< wxRect * >(argp1);
6930 ecode2 = SWIG_AsVal_int(obj1, &val2);
6931 if (!SWIG_IsOK(ecode2)) {
6932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6933 }
6934 arg2 = static_cast< int >(val2);
6935 {
6936 PyThreadState* __tstate = wxPyBeginAllowThreads();
6937 (arg1)->SetRight(arg2);
6938 wxPyEndAllowThreads(__tstate);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 resultobj = SWIG_Py_Void();
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj = 0;
6950 wxRect *arg1 = (wxRect *) 0 ;
6951 int arg2 ;
6952 void *argp1 = 0 ;
6953 int res1 = 0 ;
6954 int val2 ;
6955 int ecode2 = 0 ;
6956 PyObject * obj0 = 0 ;
6957 PyObject * obj1 = 0 ;
6958 char * kwnames[] = {
6959 (char *) "self",(char *) "top", NULL
6960 };
6961
6962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6964 if (!SWIG_IsOK(res1)) {
6965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6966 }
6967 arg1 = reinterpret_cast< wxRect * >(argp1);
6968 ecode2 = SWIG_AsVal_int(obj1, &val2);
6969 if (!SWIG_IsOK(ecode2)) {
6970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6971 }
6972 arg2 = static_cast< int >(val2);
6973 {
6974 PyThreadState* __tstate = wxPyBeginAllowThreads();
6975 (arg1)->SetTop(arg2);
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_Py_Void();
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6987 PyObject *resultobj = 0;
6988 wxRect *arg1 = (wxRect *) 0 ;
6989 int arg2 ;
6990 void *argp1 = 0 ;
6991 int res1 = 0 ;
6992 int val2 ;
6993 int ecode2 = 0 ;
6994 PyObject * obj0 = 0 ;
6995 PyObject * obj1 = 0 ;
6996 char * kwnames[] = {
6997 (char *) "self",(char *) "bottom", NULL
6998 };
6999
7000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7002 if (!SWIG_IsOK(res1)) {
7003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7004 }
7005 arg1 = reinterpret_cast< wxRect * >(argp1);
7006 ecode2 = SWIG_AsVal_int(obj1, &val2);
7007 if (!SWIG_IsOK(ecode2)) {
7008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7009 }
7010 arg2 = static_cast< int >(val2);
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 (arg1)->SetBottom(arg2);
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_Py_Void();
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj = 0;
7026 wxRect *arg1 = (wxRect *) 0 ;
7027 int arg2 ;
7028 int arg3 ;
7029 wxRect *result = 0 ;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 int val2 ;
7033 int ecode2 = 0 ;
7034 int val3 ;
7035 int ecode3 = 0 ;
7036 PyObject * obj0 = 0 ;
7037 PyObject * obj1 = 0 ;
7038 PyObject * obj2 = 0 ;
7039 char * kwnames[] = {
7040 (char *) "self",(char *) "dx",(char *) "dy", NULL
7041 };
7042
7043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 ecode2 = SWIG_AsVal_int(obj1, &val2);
7050 if (!SWIG_IsOK(ecode2)) {
7051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7052 }
7053 arg2 = static_cast< int >(val2);
7054 ecode3 = SWIG_AsVal_int(obj2, &val3);
7055 if (!SWIG_IsOK(ecode3)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7057 }
7058 arg3 = static_cast< int >(val3);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 {
7062 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7063 result = (wxRect *) &_result_ref;
7064 }
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj = 0;
7077 wxRect *arg1 = (wxRect *) 0 ;
7078 int arg2 ;
7079 int arg3 ;
7080 wxRect *result = 0 ;
7081 void *argp1 = 0 ;
7082 int res1 = 0 ;
7083 int val2 ;
7084 int ecode2 = 0 ;
7085 int val3 ;
7086 int ecode3 = 0 ;
7087 PyObject * obj0 = 0 ;
7088 PyObject * obj1 = 0 ;
7089 PyObject * obj2 = 0 ;
7090 char * kwnames[] = {
7091 (char *) "self",(char *) "dx",(char *) "dy", NULL
7092 };
7093
7094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7096 if (!SWIG_IsOK(res1)) {
7097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7098 }
7099 arg1 = reinterpret_cast< wxRect * >(argp1);
7100 ecode2 = SWIG_AsVal_int(obj1, &val2);
7101 if (!SWIG_IsOK(ecode2)) {
7102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7103 }
7104 arg2 = static_cast< int >(val2);
7105 ecode3 = SWIG_AsVal_int(obj2, &val3);
7106 if (!SWIG_IsOK(ecode3)) {
7107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7108 }
7109 arg3 = static_cast< int >(val3);
7110 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 {
7113 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7114 result = (wxRect *) &_result_ref;
7115 }
7116 wxPyEndAllowThreads(__tstate);
7117 if (PyErr_Occurred()) SWIG_fail;
7118 }
7119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7120 return resultobj;
7121 fail:
7122 return NULL;
7123 }
7124
7125
7126 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj = 0;
7128 wxRect *arg1 = (wxRect *) 0 ;
7129 int arg2 ;
7130 int arg3 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 int val2 ;
7134 int ecode2 = 0 ;
7135 int val3 ;
7136 int ecode3 = 0 ;
7137 PyObject * obj0 = 0 ;
7138 PyObject * obj1 = 0 ;
7139 PyObject * obj2 = 0 ;
7140 char * kwnames[] = {
7141 (char *) "self",(char *) "dx",(char *) "dy", NULL
7142 };
7143
7144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7146 if (!SWIG_IsOK(res1)) {
7147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7148 }
7149 arg1 = reinterpret_cast< wxRect * >(argp1);
7150 ecode2 = SWIG_AsVal_int(obj1, &val2);
7151 if (!SWIG_IsOK(ecode2)) {
7152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7153 }
7154 arg2 = static_cast< int >(val2);
7155 ecode3 = SWIG_AsVal_int(obj2, &val3);
7156 if (!SWIG_IsOK(ecode3)) {
7157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7158 }
7159 arg3 = static_cast< int >(val3);
7160 {
7161 PyThreadState* __tstate = wxPyBeginAllowThreads();
7162 (arg1)->Offset(arg2,arg3);
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 resultobj = SWIG_Py_Void();
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj = 0;
7175 wxRect *arg1 = (wxRect *) 0 ;
7176 wxPoint *arg2 = 0 ;
7177 void *argp1 = 0 ;
7178 int res1 = 0 ;
7179 wxPoint temp2 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char * kwnames[] = {
7183 (char *) "self",(char *) "pt", NULL
7184 };
7185
7186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7188 if (!SWIG_IsOK(res1)) {
7189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7190 }
7191 arg1 = reinterpret_cast< wxRect * >(argp1);
7192 {
7193 arg2 = &temp2;
7194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7195 }
7196 {
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 (arg1)->Offset((wxPoint const &)*arg2);
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 resultobj = SWIG_Py_Void();
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj = 0;
7211 wxRect *arg1 = (wxRect *) 0 ;
7212 wxRect *arg2 = 0 ;
7213 wxRect result;
7214 void *argp1 = 0 ;
7215 int res1 = 0 ;
7216 wxRect temp2 ;
7217 PyObject * obj0 = 0 ;
7218 PyObject * obj1 = 0 ;
7219 char * kwnames[] = {
7220 (char *) "self",(char *) "rect", NULL
7221 };
7222
7223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7225 if (!SWIG_IsOK(res1)) {
7226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7227 }
7228 arg1 = reinterpret_cast< wxRect * >(argp1);
7229 {
7230 arg2 = &temp2;
7231 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7232 }
7233 {
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 result = (arg1)->Intersect((wxRect const &)*arg2);
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7247 PyObject *resultobj = 0;
7248 wxRect *arg1 = (wxRect *) 0 ;
7249 wxRect *arg2 = 0 ;
7250 wxRect result;
7251 void *argp1 = 0 ;
7252 int res1 = 0 ;
7253 wxRect temp2 ;
7254 PyObject * obj0 = 0 ;
7255 PyObject * obj1 = 0 ;
7256 char * kwnames[] = {
7257 (char *) "self",(char *) "rect", NULL
7258 };
7259
7260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7262 if (!SWIG_IsOK(res1)) {
7263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7264 }
7265 arg1 = reinterpret_cast< wxRect * >(argp1);
7266 {
7267 arg2 = &temp2;
7268 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7269 }
7270 {
7271 PyThreadState* __tstate = wxPyBeginAllowThreads();
7272 result = (arg1)->Union((wxRect const &)*arg2);
7273 wxPyEndAllowThreads(__tstate);
7274 if (PyErr_Occurred()) SWIG_fail;
7275 }
7276 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7284 PyObject *resultobj = 0;
7285 wxRect *arg1 = (wxRect *) 0 ;
7286 wxRect *arg2 = 0 ;
7287 wxRect result;
7288 void *argp1 = 0 ;
7289 int res1 = 0 ;
7290 wxRect temp2 ;
7291 PyObject * obj0 = 0 ;
7292 PyObject * obj1 = 0 ;
7293 char * kwnames[] = {
7294 (char *) "self",(char *) "rect", NULL
7295 };
7296
7297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7299 if (!SWIG_IsOK(res1)) {
7300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7301 }
7302 arg1 = reinterpret_cast< wxRect * >(argp1);
7303 {
7304 arg2 = &temp2;
7305 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7306 }
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 wxRect *arg2 = 0 ;
7324 wxRect *result = 0 ;
7325 void *argp1 = 0 ;
7326 int res1 = 0 ;
7327 wxRect temp2 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 char * kwnames[] = {
7331 (char *) "self",(char *) "rect", NULL
7332 };
7333
7334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7336 if (!SWIG_IsOK(res1)) {
7337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7338 }
7339 arg1 = reinterpret_cast< wxRect * >(argp1);
7340 {
7341 arg2 = &temp2;
7342 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7343 }
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 {
7347 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7348 result = (wxRect *) &_result_ref;
7349 }
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7354 return resultobj;
7355 fail:
7356 return NULL;
7357 }
7358
7359
7360 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7361 PyObject *resultobj = 0;
7362 wxRect *arg1 = (wxRect *) 0 ;
7363 PyObject *arg2 = (PyObject *) 0 ;
7364 bool result;
7365 void *argp1 = 0 ;
7366 int res1 = 0 ;
7367 PyObject * obj0 = 0 ;
7368 PyObject * obj1 = 0 ;
7369 char * kwnames[] = {
7370 (char *) "self",(char *) "other", NULL
7371 };
7372
7373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7375 if (!SWIG_IsOK(res1)) {
7376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7377 }
7378 arg1 = reinterpret_cast< wxRect * >(argp1);
7379 arg2 = obj1;
7380 {
7381 result = (bool)wxRect___eq__(arg1,arg2);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 {
7385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7386 }
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj = 0;
7395 wxRect *arg1 = (wxRect *) 0 ;
7396 PyObject *arg2 = (PyObject *) 0 ;
7397 bool result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject * obj0 = 0 ;
7401 PyObject * obj1 = 0 ;
7402 char * kwnames[] = {
7403 (char *) "self",(char *) "other", NULL
7404 };
7405
7406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7408 if (!SWIG_IsOK(res1)) {
7409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7410 }
7411 arg1 = reinterpret_cast< wxRect * >(argp1);
7412 arg2 = obj1;
7413 {
7414 result = (bool)wxRect___ne__(arg1,arg2);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 int arg2 ;
7430 int arg3 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 int val2 ;
7435 int ecode2 = 0 ;
7436 int val3 ;
7437 int ecode3 = 0 ;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 PyObject * obj2 = 0 ;
7441 char * kwnames[] = {
7442 (char *) "self",(char *) "x",(char *) "y", NULL
7443 };
7444
7445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7447 if (!SWIG_IsOK(res1)) {
7448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7449 }
7450 arg1 = reinterpret_cast< wxRect * >(argp1);
7451 ecode2 = SWIG_AsVal_int(obj1, &val2);
7452 if (!SWIG_IsOK(ecode2)) {
7453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7454 }
7455 arg2 = static_cast< int >(val2);
7456 ecode3 = SWIG_AsVal_int(obj2, &val3);
7457 if (!SWIG_IsOK(ecode3)) {
7458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7459 }
7460 arg3 = static_cast< int >(val3);
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 {
7468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7469 }
7470 return resultobj;
7471 fail:
7472 return NULL;
7473 }
7474
7475
7476 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7477 PyObject *resultobj = 0;
7478 wxRect *arg1 = (wxRect *) 0 ;
7479 wxPoint *arg2 = 0 ;
7480 bool result;
7481 void *argp1 = 0 ;
7482 int res1 = 0 ;
7483 wxPoint temp2 ;
7484 PyObject * obj0 = 0 ;
7485 PyObject * obj1 = 0 ;
7486 char * kwnames[] = {
7487 (char *) "self",(char *) "pt", NULL
7488 };
7489
7490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7492 if (!SWIG_IsOK(res1)) {
7493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7494 }
7495 arg1 = reinterpret_cast< wxRect * >(argp1);
7496 {
7497 arg2 = &temp2;
7498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7499 }
7500 {
7501 PyThreadState* __tstate = wxPyBeginAllowThreads();
7502 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7503 wxPyEndAllowThreads(__tstate);
7504 if (PyErr_Occurred()) SWIG_fail;
7505 }
7506 {
7507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7508 }
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj = 0;
7517 wxRect *arg1 = (wxRect *) 0 ;
7518 wxRect *arg2 = 0 ;
7519 bool result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 wxRect temp2 ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char * kwnames[] = {
7526 (char *) "self",(char *) "rect", NULL
7527 };
7528
7529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7533 }
7534 arg1 = reinterpret_cast< wxRect * >(argp1);
7535 {
7536 arg2 = &temp2;
7537 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7538 }
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 int arg3 = (int) wxBOTH ;
7559 wxRect result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 wxRect temp2 ;
7563 int val3 ;
7564 int ecode3 = 0 ;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 PyObject * obj2 = 0 ;
7568 char * kwnames[] = {
7569 (char *) "self",(char *) "r",(char *) "dir", NULL
7570 };
7571
7572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7574 if (!SWIG_IsOK(res1)) {
7575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7576 }
7577 arg1 = reinterpret_cast< wxRect * >(argp1);
7578 {
7579 arg2 = &temp2;
7580 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7581 }
7582 if (obj2) {
7583 ecode3 = SWIG_AsVal_int(obj2, &val3);
7584 if (!SWIG_IsOK(ecode3)) {
7585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7586 }
7587 arg3 = static_cast< int >(val3);
7588 }
7589 {
7590 PyThreadState* __tstate = wxPyBeginAllowThreads();
7591 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7592 wxPyEndAllowThreads(__tstate);
7593 if (PyErr_Occurred()) SWIG_fail;
7594 }
7595 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 int arg2 ;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 int val2 ;
7609 int ecode2 = 0 ;
7610 PyObject *swig_obj[2] ;
7611
7612 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7616 }
7617 arg1 = reinterpret_cast< wxRect * >(argp1);
7618 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7619 if (!SWIG_IsOK(ecode2)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7621 }
7622 arg2 = static_cast< int >(val2);
7623 if (arg1) (arg1)->x = arg2;
7624
7625 resultobj = SWIG_Py_Void();
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxRect *arg1 = (wxRect *) 0 ;
7635 int result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7645 }
7646 arg1 = reinterpret_cast< wxRect * >(argp1);
7647 result = (int) ((arg1)->x);
7648 resultobj = SWIG_From_int(static_cast< int >(result));
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7656 PyObject *resultobj = 0;
7657 wxRect *arg1 = (wxRect *) 0 ;
7658 int arg2 ;
7659 void *argp1 = 0 ;
7660 int res1 = 0 ;
7661 int val2 ;
7662 int ecode2 = 0 ;
7663 PyObject *swig_obj[2] ;
7664
7665 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7672 if (!SWIG_IsOK(ecode2)) {
7673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7674 }
7675 arg2 = static_cast< int >(val2);
7676 if (arg1) (arg1)->y = arg2;
7677
7678 resultobj = SWIG_Py_Void();
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 int result;
7689 void *argp1 = 0 ;
7690 int res1 = 0 ;
7691 PyObject *swig_obj[1] ;
7692
7693 if (!args) SWIG_fail;
7694 swig_obj[0] = args;
7695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7698 }
7699 arg1 = reinterpret_cast< wxRect * >(argp1);
7700 result = (int) ((arg1)->y);
7701 resultobj = SWIG_From_int(static_cast< int >(result));
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject *swig_obj[2] ;
7717
7718 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7722 }
7723 arg1 = reinterpret_cast< wxRect * >(argp1);
7724 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 if (arg1) (arg1)->width = arg2;
7730
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7739 PyObject *resultobj = 0;
7740 wxRect *arg1 = (wxRect *) 0 ;
7741 int result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 PyObject *swig_obj[1] ;
7745
7746 if (!args) SWIG_fail;
7747 swig_obj[0] = args;
7748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 result = (int) ((arg1)->width);
7754 resultobj = SWIG_From_int(static_cast< int >(result));
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 int arg2 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 int val2 ;
7768 int ecode2 = 0 ;
7769 PyObject *swig_obj[2] ;
7770
7771 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 if (arg1) (arg1)->height = arg2;
7783
7784 resultobj = SWIG_Py_Void();
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 int result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 PyObject *swig_obj[1] ;
7798
7799 if (!args) SWIG_fail;
7800 swig_obj[0] = args;
7801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7802 if (!SWIG_IsOK(res1)) {
7803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7804 }
7805 arg1 = reinterpret_cast< wxRect * >(argp1);
7806 result = (int) ((arg1)->height);
7807 resultobj = SWIG_From_int(static_cast< int >(result));
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 int arg2 = (int) 0 ;
7818 int arg3 = (int) 0 ;
7819 int arg4 = (int) 0 ;
7820 int arg5 = (int) 0 ;
7821 void *argp1 = 0 ;
7822 int res1 = 0 ;
7823 int val2 ;
7824 int ecode2 = 0 ;
7825 int val3 ;
7826 int ecode3 = 0 ;
7827 int val4 ;
7828 int ecode4 = 0 ;
7829 int val5 ;
7830 int ecode5 = 0 ;
7831 PyObject * obj0 = 0 ;
7832 PyObject * obj1 = 0 ;
7833 PyObject * obj2 = 0 ;
7834 PyObject * obj3 = 0 ;
7835 PyObject * obj4 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7844 }
7845 arg1 = reinterpret_cast< wxRect * >(argp1);
7846 if (obj1) {
7847 ecode2 = SWIG_AsVal_int(obj1, &val2);
7848 if (!SWIG_IsOK(ecode2)) {
7849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7850 }
7851 arg2 = static_cast< int >(val2);
7852 }
7853 if (obj2) {
7854 ecode3 = SWIG_AsVal_int(obj2, &val3);
7855 if (!SWIG_IsOK(ecode3)) {
7856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7857 }
7858 arg3 = static_cast< int >(val3);
7859 }
7860 if (obj3) {
7861 ecode4 = SWIG_AsVal_int(obj3, &val4);
7862 if (!SWIG_IsOK(ecode4)) {
7863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7864 }
7865 arg4 = static_cast< int >(val4);
7866 }
7867 if (obj4) {
7868 ecode5 = SWIG_AsVal_int(obj4, &val5);
7869 if (!SWIG_IsOK(ecode5)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7871 }
7872 arg5 = static_cast< int >(val5);
7873 }
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_Py_Void();
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7888 PyObject *resultobj = 0;
7889 wxRect *arg1 = (wxRect *) 0 ;
7890 PyObject *result = 0 ;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 PyObject *swig_obj[1] ;
7894
7895 if (!args) SWIG_fail;
7896 swig_obj[0] = args;
7897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7898 if (!SWIG_IsOK(res1)) {
7899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7900 }
7901 arg1 = reinterpret_cast< wxRect * >(argp1);
7902 {
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 result = (PyObject *)wxRect_Get(arg1);
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 resultobj = result;
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *obj;
7917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7918 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7919 return SWIG_Py_Void();
7920 }
7921
7922 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7923 return SWIG_Python_InitShadowInstance(args);
7924 }
7925
7926 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7927 PyObject *resultobj = 0;
7928 wxRect *arg1 = (wxRect *) 0 ;
7929 wxRect *arg2 = (wxRect *) 0 ;
7930 PyObject *result = 0 ;
7931 void *argp1 = 0 ;
7932 int res1 = 0 ;
7933 void *argp2 = 0 ;
7934 int res2 = 0 ;
7935 PyObject * obj0 = 0 ;
7936 PyObject * obj1 = 0 ;
7937 char * kwnames[] = {
7938 (char *) "r1",(char *) "r2", NULL
7939 };
7940
7941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7943 if (!SWIG_IsOK(res1)) {
7944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7945 }
7946 arg1 = reinterpret_cast< wxRect * >(argp1);
7947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7948 if (!SWIG_IsOK(res2)) {
7949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7950 }
7951 arg2 = reinterpret_cast< wxRect * >(argp2);
7952 {
7953 if (!wxPyCheckForApp()) SWIG_fail;
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 result = (PyObject *)wxIntersectRect(arg1,arg2);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = result;
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7967 PyObject *resultobj = 0;
7968 double arg1 = (double) 0.0 ;
7969 double arg2 = (double) 0.0 ;
7970 wxPoint2D *result = 0 ;
7971 double val1 ;
7972 int ecode1 = 0 ;
7973 double val2 ;
7974 int ecode2 = 0 ;
7975 PyObject * obj0 = 0 ;
7976 PyObject * obj1 = 0 ;
7977 char * kwnames[] = {
7978 (char *) "x",(char *) "y", NULL
7979 };
7980
7981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7982 if (obj0) {
7983 ecode1 = SWIG_AsVal_double(obj0, &val1);
7984 if (!SWIG_IsOK(ecode1)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7986 }
7987 arg1 = static_cast< double >(val1);
7988 }
7989 if (obj1) {
7990 ecode2 = SWIG_AsVal_double(obj1, &val2);
7991 if (!SWIG_IsOK(ecode2)) {
7992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7993 }
7994 arg2 = static_cast< double >(val2);
7995 }
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxPoint2D *arg1 = 0 ;
8012 wxPoint2D *result = 0 ;
8013 wxPoint2D temp1 ;
8014 PyObject * obj0 = 0 ;
8015 char * kwnames[] = {
8016 (char *) "pt", NULL
8017 };
8018
8019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8020 {
8021 arg1 = &temp1;
8022 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8023 }
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8038 PyObject *resultobj = 0;
8039 wxPoint *arg1 = 0 ;
8040 wxPoint2D *result = 0 ;
8041 wxPoint temp1 ;
8042 PyObject * obj0 = 0 ;
8043 char * kwnames[] = {
8044 (char *) "pt", NULL
8045 };
8046
8047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8048 {
8049 arg1 = &temp1;
8050 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8051 }
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8066 PyObject *resultobj = 0;
8067 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8068 int *arg2 = (int *) 0 ;
8069 int *arg3 = (int *) 0 ;
8070 void *argp1 = 0 ;
8071 int res1 = 0 ;
8072 int temp2 ;
8073 int res2 = SWIG_TMPOBJ ;
8074 int temp3 ;
8075 int res3 = SWIG_TMPOBJ ;
8076 PyObject *swig_obj[1] ;
8077
8078 arg2 = &temp2;
8079 arg3 = &temp3;
8080 if (!args) SWIG_fail;
8081 swig_obj[0] = args;
8082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8083 if (!SWIG_IsOK(res1)) {
8084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8085 }
8086 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_Py_Void();
8094 if (SWIG_IsTmpObj(res2)) {
8095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8096 } else {
8097 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8099 }
8100 if (SWIG_IsTmpObj(res3)) {
8101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8102 } else {
8103 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 PyObject *resultobj = 0;
8114 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8115 int *arg2 = (int *) 0 ;
8116 int *arg3 = (int *) 0 ;
8117 void *argp1 = 0 ;
8118 int res1 = 0 ;
8119 int temp2 ;
8120 int res2 = SWIG_TMPOBJ ;
8121 int temp3 ;
8122 int res3 = SWIG_TMPOBJ ;
8123 PyObject *swig_obj[1] ;
8124
8125 arg2 = &temp2;
8126 arg3 = &temp3;
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8132 }
8133 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 if (SWIG_IsTmpObj(res2)) {
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8143 } else {
8144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8146 }
8147 if (SWIG_IsTmpObj(res3)) {
8148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8149 } else {
8150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8152 }
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8162 double result;
8163 void *argp1 = 0 ;
8164 int res1 = 0 ;
8165 PyObject *swig_obj[1] ;
8166
8167 if (!args) SWIG_fail;
8168 swig_obj[0] = args;
8169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8170 if (!SWIG_IsOK(res1)) {
8171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8172 }
8173 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8174 {
8175 PyThreadState* __tstate = wxPyBeginAllowThreads();
8176 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 resultobj = SWIG_From_double(static_cast< double >(result));
8181 return resultobj;
8182 fail:
8183 return NULL;
8184 }
8185
8186
8187 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8188 PyObject *resultobj = 0;
8189 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8190 double result;
8191 void *argp1 = 0 ;
8192 int res1 = 0 ;
8193 PyObject *swig_obj[1] ;
8194
8195 if (!args) SWIG_fail;
8196 swig_obj[0] = args;
8197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8198 if (!SWIG_IsOK(res1)) {
8199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8200 }
8201 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8202 {
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_From_double(static_cast< double >(result));
8209 return resultobj;
8210 fail:
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8216 PyObject *resultobj = 0;
8217 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8218 double arg2 ;
8219 void *argp1 = 0 ;
8220 int res1 = 0 ;
8221 double val2 ;
8222 int ecode2 = 0 ;
8223 PyObject * obj0 = 0 ;
8224 PyObject * obj1 = 0 ;
8225 char * kwnames[] = {
8226 (char *) "self",(char *) "length", NULL
8227 };
8228
8229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8231 if (!SWIG_IsOK(res1)) {
8232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8233 }
8234 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8235 ecode2 = SWIG_AsVal_double(obj1, &val2);
8236 if (!SWIG_IsOK(ecode2)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8238 }
8239 arg2 = static_cast< double >(val2);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 (arg1)->SetVectorLength(arg2);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 return resultobj;
8248 fail:
8249 return NULL;
8250 }
8251
8252
8253 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj = 0;
8255 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8256 double arg2 ;
8257 void *argp1 = 0 ;
8258 int res1 = 0 ;
8259 double val2 ;
8260 int ecode2 = 0 ;
8261 PyObject * obj0 = 0 ;
8262 PyObject * obj1 = 0 ;
8263 char * kwnames[] = {
8264 (char *) "self",(char *) "degrees", NULL
8265 };
8266
8267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8269 if (!SWIG_IsOK(res1)) {
8270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8271 }
8272 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8273 ecode2 = SWIG_AsVal_double(obj1, &val2);
8274 if (!SWIG_IsOK(ecode2)) {
8275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8276 }
8277 arg2 = static_cast< double >(val2);
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 (arg1)->SetVectorAngle(arg2);
8281 wxPyEndAllowThreads(__tstate);
8282 if (PyErr_Occurred()) SWIG_fail;
8283 }
8284 resultobj = SWIG_Py_Void();
8285 return resultobj;
8286 fail:
8287 return NULL;
8288 }
8289
8290
8291 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8292 PyObject *resultobj = 0;
8293 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8294 wxPoint2D *arg2 = 0 ;
8295 double result;
8296 void *argp1 = 0 ;
8297 int res1 = 0 ;
8298 wxPoint2D temp2 ;
8299 PyObject * obj0 = 0 ;
8300 PyObject * obj1 = 0 ;
8301 char * kwnames[] = {
8302 (char *) "self",(char *) "pt", NULL
8303 };
8304
8305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8307 if (!SWIG_IsOK(res1)) {
8308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8309 }
8310 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8311 {
8312 arg2 = &temp2;
8313 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8314 }
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8318 wxPyEndAllowThreads(__tstate);
8319 if (PyErr_Occurred()) SWIG_fail;
8320 }
8321 resultobj = SWIG_From_double(static_cast< double >(result));
8322 return resultobj;
8323 fail:
8324 return NULL;
8325 }
8326
8327
8328 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8329 PyObject *resultobj = 0;
8330 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8331 wxPoint2D *arg2 = 0 ;
8332 double result;
8333 void *argp1 = 0 ;
8334 int res1 = 0 ;
8335 wxPoint2D temp2 ;
8336 PyObject * obj0 = 0 ;
8337 PyObject * obj1 = 0 ;
8338 char * kwnames[] = {
8339 (char *) "self",(char *) "pt", NULL
8340 };
8341
8342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 arg2 = &temp2;
8350 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8351 }
8352 {
8353 PyThreadState* __tstate = wxPyBeginAllowThreads();
8354 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 resultobj = SWIG_From_double(static_cast< double >(result));
8359 return resultobj;
8360 fail:
8361 return NULL;
8362 }
8363
8364
8365 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj = 0;
8367 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8368 wxPoint2D *arg2 = 0 ;
8369 double result;
8370 void *argp1 = 0 ;
8371 int res1 = 0 ;
8372 wxPoint2D temp2 ;
8373 PyObject * obj0 = 0 ;
8374 PyObject * obj1 = 0 ;
8375 char * kwnames[] = {
8376 (char *) "self",(char *) "vec", NULL
8377 };
8378
8379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8381 if (!SWIG_IsOK(res1)) {
8382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8383 }
8384 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8385 {
8386 arg2 = &temp2;
8387 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8388 }
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_From_double(static_cast< double >(result));
8396 return resultobj;
8397 fail:
8398 return NULL;
8399 }
8400
8401
8402 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj = 0;
8404 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8405 wxPoint2D *arg2 = 0 ;
8406 double result;
8407 void *argp1 = 0 ;
8408 int res1 = 0 ;
8409 wxPoint2D temp2 ;
8410 PyObject * obj0 = 0 ;
8411 PyObject * obj1 = 0 ;
8412 char * kwnames[] = {
8413 (char *) "self",(char *) "vec", NULL
8414 };
8415
8416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8418 if (!SWIG_IsOK(res1)) {
8419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8420 }
8421 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8422 {
8423 arg2 = &temp2;
8424 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8425 }
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 resultobj = SWIG_From_double(static_cast< double >(result));
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8440 PyObject *resultobj = 0;
8441 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8442 wxPoint2D result;
8443 void *argp1 = 0 ;
8444 int res1 = 0 ;
8445 PyObject *swig_obj[1] ;
8446
8447 if (!args) SWIG_fail;
8448 swig_obj[0] = args;
8449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 {
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (arg1)->operator -();
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8468 PyObject *resultobj = 0;
8469 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8470 wxPoint2D *arg2 = 0 ;
8471 wxPoint2D *result = 0 ;
8472 void *argp1 = 0 ;
8473 int res1 = 0 ;
8474 wxPoint2D temp2 ;
8475 PyObject * obj0 = 0 ;
8476 PyObject * obj1 = 0 ;
8477 char * kwnames[] = {
8478 (char *) "self",(char *) "pt", NULL
8479 };
8480
8481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 arg2 = &temp2;
8489 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8490 }
8491 {
8492 PyThreadState* __tstate = wxPyBeginAllowThreads();
8493 {
8494 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8495 result = (wxPoint2D *) &_result_ref;
8496 }
8497 wxPyEndAllowThreads(__tstate);
8498 if (PyErr_Occurred()) SWIG_fail;
8499 }
8500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj = 0;
8509 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8510 wxPoint2D *arg2 = 0 ;
8511 wxPoint2D *result = 0 ;
8512 void *argp1 = 0 ;
8513 int res1 = 0 ;
8514 wxPoint2D temp2 ;
8515 PyObject * obj0 = 0 ;
8516 PyObject * obj1 = 0 ;
8517 char * kwnames[] = {
8518 (char *) "self",(char *) "pt", NULL
8519 };
8520
8521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8523 if (!SWIG_IsOK(res1)) {
8524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8525 }
8526 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8527 {
8528 arg2 = &temp2;
8529 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8530 }
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 {
8534 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8535 result = (wxPoint2D *) &_result_ref;
8536 }
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj = 0;
8549 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8550 wxPoint2D *arg2 = 0 ;
8551 wxPoint2D *result = 0 ;
8552 void *argp1 = 0 ;
8553 int res1 = 0 ;
8554 wxPoint2D temp2 ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 char * kwnames[] = {
8558 (char *) "self",(char *) "pt", NULL
8559 };
8560
8561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8565 }
8566 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8567 {
8568 arg2 = &temp2;
8569 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 {
8574 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8575 result = (wxPoint2D *) &_result_ref;
8576 }
8577 wxPyEndAllowThreads(__tstate);
8578 if (PyErr_Occurred()) SWIG_fail;
8579 }
8580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8581 return resultobj;
8582 fail:
8583 return NULL;
8584 }
8585
8586
8587 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8588 PyObject *resultobj = 0;
8589 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8590 wxPoint2D *arg2 = 0 ;
8591 wxPoint2D *result = 0 ;
8592 void *argp1 = 0 ;
8593 int res1 = 0 ;
8594 wxPoint2D temp2 ;
8595 PyObject * obj0 = 0 ;
8596 PyObject * obj1 = 0 ;
8597 char * kwnames[] = {
8598 (char *) "self",(char *) "pt", NULL
8599 };
8600
8601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8603 if (!SWIG_IsOK(res1)) {
8604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8605 }
8606 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8607 {
8608 arg2 = &temp2;
8609 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8610 }
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 {
8614 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8615 result = (wxPoint2D *) &_result_ref;
8616 }
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8621 return resultobj;
8622 fail:
8623 return NULL;
8624 }
8625
8626
8627 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8628 PyObject *resultobj = 0;
8629 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8630 PyObject *arg2 = (PyObject *) 0 ;
8631 bool result;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "other", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 arg2 = obj1;
8647 {
8648 result = (bool)wxPoint2D___eq__(arg1,arg2);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 {
8652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8653 }
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 PyObject *arg2 = (PyObject *) 0 ;
8664 bool result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 PyObject * obj0 = 0 ;
8668 PyObject * obj1 = 0 ;
8669 char * kwnames[] = {
8670 (char *) "self",(char *) "other", NULL
8671 };
8672
8673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8675 if (!SWIG_IsOK(res1)) {
8676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8677 }
8678 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8679 arg2 = obj1;
8680 {
8681 result = (bool)wxPoint2D___ne__(arg1,arg2);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 {
8685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8686 }
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 double arg2 ;
8697 void *argp1 = 0 ;
8698 int res1 = 0 ;
8699 double val2 ;
8700 int ecode2 = 0 ;
8701 PyObject *swig_obj[2] ;
8702
8703 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8705 if (!SWIG_IsOK(res1)) {
8706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8707 }
8708 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8709 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8710 if (!SWIG_IsOK(ecode2)) {
8711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8712 }
8713 arg2 = static_cast< double >(val2);
8714 if (arg1) (arg1)->m_x = arg2;
8715
8716 resultobj = SWIG_Py_Void();
8717 return resultobj;
8718 fail:
8719 return NULL;
8720 }
8721
8722
8723 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8724 PyObject *resultobj = 0;
8725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8726 double result;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 PyObject *swig_obj[1] ;
8730
8731 if (!args) SWIG_fail;
8732 swig_obj[0] = args;
8733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8736 }
8737 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8738 result = (double) ((arg1)->m_x);
8739 resultobj = SWIG_From_double(static_cast< double >(result));
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8747 PyObject *resultobj = 0;
8748 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8749 double arg2 ;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 double val2 ;
8753 int ecode2 = 0 ;
8754 PyObject *swig_obj[2] ;
8755
8756 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8758 if (!SWIG_IsOK(res1)) {
8759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8760 }
8761 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8762 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8763 if (!SWIG_IsOK(ecode2)) {
8764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8765 }
8766 arg2 = static_cast< double >(val2);
8767 if (arg1) (arg1)->m_y = arg2;
8768
8769 resultobj = SWIG_Py_Void();
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8777 PyObject *resultobj = 0;
8778 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8779 double result;
8780 void *argp1 = 0 ;
8781 int res1 = 0 ;
8782 PyObject *swig_obj[1] ;
8783
8784 if (!args) SWIG_fail;
8785 swig_obj[0] = args;
8786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8787 if (!SWIG_IsOK(res1)) {
8788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8789 }
8790 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8791 result = (double) ((arg1)->m_y);
8792 resultobj = SWIG_From_double(static_cast< double >(result));
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8800 PyObject *resultobj = 0;
8801 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8802 double arg2 = (double) 0 ;
8803 double arg3 = (double) 0 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 double val3 ;
8809 int ecode3 = 0 ;
8810 PyObject * obj0 = 0 ;
8811 PyObject * obj1 = 0 ;
8812 PyObject * obj2 = 0 ;
8813 char * kwnames[] = {
8814 (char *) "self",(char *) "x",(char *) "y", NULL
8815 };
8816
8817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8819 if (!SWIG_IsOK(res1)) {
8820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8821 }
8822 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8823 if (obj1) {
8824 ecode2 = SWIG_AsVal_double(obj1, &val2);
8825 if (!SWIG_IsOK(ecode2)) {
8826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8827 }
8828 arg2 = static_cast< double >(val2);
8829 }
8830 if (obj2) {
8831 ecode3 = SWIG_AsVal_double(obj2, &val3);
8832 if (!SWIG_IsOK(ecode3)) {
8833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8834 }
8835 arg3 = static_cast< double >(val3);
8836 }
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 wxPoint2D_Set(arg1,arg2,arg3);
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_Py_Void();
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8851 PyObject *resultobj = 0;
8852 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8853 PyObject *result = 0 ;
8854 void *argp1 = 0 ;
8855 int res1 = 0 ;
8856 PyObject *swig_obj[1] ;
8857
8858 if (!args) SWIG_fail;
8859 swig_obj[0] = args;
8860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8861 if (!SWIG_IsOK(res1)) {
8862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8863 }
8864 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 result = (PyObject *)wxPoint2D_Get(arg1);
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 resultobj = result;
8872 return resultobj;
8873 fail:
8874 return NULL;
8875 }
8876
8877
8878 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8879 PyObject *obj;
8880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8881 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8882 return SWIG_Py_Void();
8883 }
8884
8885 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8886 return SWIG_Python_InitShadowInstance(args);
8887 }
8888
8889 SWIGINTERN int DefaultPosition_set(PyObject *) {
8890 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8891 return 1;
8892 }
8893
8894
8895 SWIGINTERN PyObject *DefaultPosition_get(void) {
8896 PyObject *pyobj = 0;
8897
8898 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8899 return pyobj;
8900 }
8901
8902
8903 SWIGINTERN int DefaultSize_set(PyObject *) {
8904 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8905 return 1;
8906 }
8907
8908
8909 SWIGINTERN PyObject *DefaultSize_get(void) {
8910 PyObject *pyobj = 0;
8911
8912 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8913 return pyobj;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8918 PyObject *resultobj = 0;
8919 PyObject *arg1 = (PyObject *) 0 ;
8920 wxPyInputStream *result = 0 ;
8921 PyObject * obj0 = 0 ;
8922 char * kwnames[] = {
8923 (char *) "p", NULL
8924 };
8925
8926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8927 arg1 = obj0;
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 PyObject *swig_obj[1] ;
8947
8948 if (!args) SWIG_fail;
8949 swig_obj[0] = args;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 delete arg1;
8958
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 resultobj = SWIG_Py_Void();
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *resultobj = 0;
8971 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8972 void *argp1 = 0 ;
8973 int res1 = 0 ;
8974 PyObject *swig_obj[1] ;
8975
8976 if (!args) SWIG_fail;
8977 swig_obj[0] = args;
8978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8979 if (!SWIG_IsOK(res1)) {
8980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8981 }
8982 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8983 {
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 (arg1)->close();
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 resultobj = SWIG_Py_Void();
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8997 PyObject *resultobj = 0;
8998 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 PyObject *swig_obj[1] ;
9002
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9006 if (!SWIG_IsOK(res1)) {
9007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9008 }
9009 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 (arg1)->flush();
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 resultobj = SWIG_Py_Void();
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 PyObject *resultobj = 0;
9025 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9026 bool result;
9027 void *argp1 = 0 ;
9028 int res1 = 0 ;
9029 PyObject *swig_obj[1] ;
9030
9031 if (!args) SWIG_fail;
9032 swig_obj[0] = args;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 result = (bool)(arg1)->eof();
9041 wxPyEndAllowThreads(__tstate);
9042 if (PyErr_Occurred()) SWIG_fail;
9043 }
9044 {
9045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9046 }
9047 return resultobj;
9048 fail:
9049 return NULL;
9050 }
9051
9052
9053 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj = 0;
9055 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9056 int arg2 = (int) -1 ;
9057 PyObject *result = 0 ;
9058 void *argp1 = 0 ;
9059 int res1 = 0 ;
9060 int val2 ;
9061 int ecode2 = 0 ;
9062 PyObject * obj0 = 0 ;
9063 PyObject * obj1 = 0 ;
9064 char * kwnames[] = {
9065 (char *) "self",(char *) "size", NULL
9066 };
9067
9068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9070 if (!SWIG_IsOK(res1)) {
9071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9072 }
9073 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9074 if (obj1) {
9075 ecode2 = SWIG_AsVal_int(obj1, &val2);
9076 if (!SWIG_IsOK(ecode2)) {
9077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9078 }
9079 arg2 = static_cast< int >(val2);
9080 }
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 result = (PyObject *)(arg1)->read(arg2);
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = result;
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9095 PyObject *resultobj = 0;
9096 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9097 int arg2 = (int) -1 ;
9098 PyObject *result = 0 ;
9099 void *argp1 = 0 ;
9100 int res1 = 0 ;
9101 int val2 ;
9102 int ecode2 = 0 ;
9103 PyObject * obj0 = 0 ;
9104 PyObject * obj1 = 0 ;
9105 char * kwnames[] = {
9106 (char *) "self",(char *) "size", NULL
9107 };
9108
9109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9113 }
9114 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9115 if (obj1) {
9116 ecode2 = SWIG_AsVal_int(obj1, &val2);
9117 if (!SWIG_IsOK(ecode2)) {
9118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9119 }
9120 arg2 = static_cast< int >(val2);
9121 }
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 result = (PyObject *)(arg1)->readline(arg2);
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 resultobj = result;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj = 0;
9137 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9138 int arg2 = (int) -1 ;
9139 PyObject *result = 0 ;
9140 void *argp1 = 0 ;
9141 int res1 = 0 ;
9142 int val2 ;
9143 int ecode2 = 0 ;
9144 PyObject * obj0 = 0 ;
9145 PyObject * obj1 = 0 ;
9146 char * kwnames[] = {
9147 (char *) "self",(char *) "sizehint", NULL
9148 };
9149
9150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9154 }
9155 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9156 if (obj1) {
9157 ecode2 = SWIG_AsVal_int(obj1, &val2);
9158 if (!SWIG_IsOK(ecode2)) {
9159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9160 }
9161 arg2 = static_cast< int >(val2);
9162 }
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 result = (PyObject *)(arg1)->readlines(arg2);
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = result;
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj = 0;
9178 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9179 int arg2 ;
9180 int arg3 = (int) 0 ;
9181 void *argp1 = 0 ;
9182 int res1 = 0 ;
9183 int val2 ;
9184 int ecode2 = 0 ;
9185 int val3 ;
9186 int ecode3 = 0 ;
9187 PyObject * obj0 = 0 ;
9188 PyObject * obj1 = 0 ;
9189 PyObject * obj2 = 0 ;
9190 char * kwnames[] = {
9191 (char *) "self",(char *) "offset",(char *) "whence", NULL
9192 };
9193
9194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9196 if (!SWIG_IsOK(res1)) {
9197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9198 }
9199 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9200 ecode2 = SWIG_AsVal_int(obj1, &val2);
9201 if (!SWIG_IsOK(ecode2)) {
9202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9203 }
9204 arg2 = static_cast< int >(val2);
9205 if (obj2) {
9206 ecode3 = SWIG_AsVal_int(obj2, &val3);
9207 if (!SWIG_IsOK(ecode3)) {
9208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9209 }
9210 arg3 = static_cast< int >(val3);
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 (arg1)->seek(arg2,arg3);
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = SWIG_Py_Void();
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9228 int result;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9238 }
9239 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = (int)(arg1)->tell();
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_From_int(static_cast< int >(result));
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9256 char result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9266 }
9267 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 result = (char)(arg1)->Peek();
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 resultobj = SWIG_From_char(static_cast< char >(result));
9275 return resultobj;
9276 fail:
9277 return NULL;
9278 }
9279
9280
9281 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9282 PyObject *resultobj = 0;
9283 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9284 char result;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9294 }
9295 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 result = (char)(arg1)->GetC();
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 resultobj = SWIG_From_char(static_cast< char >(result));
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9310 PyObject *resultobj = 0;
9311 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9312 size_t result;
9313 void *argp1 = 0 ;
9314 int res1 = 0 ;
9315 PyObject *swig_obj[1] ;
9316
9317 if (!args) SWIG_fail;
9318 swig_obj[0] = args;
9319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9322 }
9323 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (size_t)(arg1)->LastRead();
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9331 return resultobj;
9332 fail:
9333 return NULL;
9334 }
9335
9336
9337 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338 PyObject *resultobj = 0;
9339 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9340 bool result;
9341 void *argp1 = 0 ;
9342 int res1 = 0 ;
9343 PyObject *swig_obj[1] ;
9344
9345 if (!args) SWIG_fail;
9346 swig_obj[0] = args;
9347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9348 if (!SWIG_IsOK(res1)) {
9349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9350 }
9351 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (bool)(arg1)->CanRead();
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 {
9359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9360 }
9361 return resultobj;
9362 fail:
9363 return NULL;
9364 }
9365
9366
9367 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9368 PyObject *resultobj = 0;
9369 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9370 bool result;
9371 void *argp1 = 0 ;
9372 int res1 = 0 ;
9373 PyObject *swig_obj[1] ;
9374
9375 if (!args) SWIG_fail;
9376 swig_obj[0] = args;
9377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9378 if (!SWIG_IsOK(res1)) {
9379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9380 }
9381 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (bool)(arg1)->Eof();
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 {
9389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9390 }
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj = 0;
9399 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9400 char arg2 ;
9401 bool result;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 char val2 ;
9405 int ecode2 = 0 ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 char * kwnames[] = {
9409 (char *) "self",(char *) "c", NULL
9410 };
9411
9412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9414 if (!SWIG_IsOK(res1)) {
9415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9416 }
9417 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9418 ecode2 = SWIG_AsVal_char(obj1, &val2);
9419 if (!SWIG_IsOK(ecode2)) {
9420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9421 }
9422 arg2 = static_cast< char >(val2);
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = (bool)(arg1)->Ungetch(arg2);
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9431 }
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
9438 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj = 0;
9440 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9441 long arg2 ;
9442 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9443 long result;
9444 void *argp1 = 0 ;
9445 int res1 = 0 ;
9446 long val2 ;
9447 int ecode2 = 0 ;
9448 int val3 ;
9449 int ecode3 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 PyObject * obj2 = 0 ;
9453 char * kwnames[] = {
9454 (char *) "self",(char *) "pos",(char *) "mode", NULL
9455 };
9456
9457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9459 if (!SWIG_IsOK(res1)) {
9460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9461 }
9462 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9463 ecode2 = SWIG_AsVal_long(obj1, &val2);
9464 if (!SWIG_IsOK(ecode2)) {
9465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9466 }
9467 arg2 = static_cast< long >(val2);
9468 if (obj2) {
9469 ecode3 = SWIG_AsVal_int(obj2, &val3);
9470 if (!SWIG_IsOK(ecode3)) {
9471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9472 }
9473 arg3 = static_cast< wxSeekMode >(val3);
9474 }
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (long)(arg1)->SeekI(arg2,arg3);
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_From_long(static_cast< long >(result));
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *resultobj = 0;
9490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9491 long result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 PyObject *swig_obj[1] ;
9495
9496 if (!args) SWIG_fail;
9497 swig_obj[0] = args;
9498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9501 }
9502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 result = (long)(arg1)->TellI();
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_From_long(static_cast< long >(result));
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9517 PyObject *obj;
9518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9519 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9520 return SWIG_Py_Void();
9521 }
9522
9523 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9524 return SWIG_Python_InitShadowInstance(args);
9525 }
9526
9527 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj = 0;
9529 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9530 PyObject *arg2 = (PyObject *) 0 ;
9531 void *argp1 = 0 ;
9532 int res1 = 0 ;
9533 PyObject * obj0 = 0 ;
9534 PyObject * obj1 = 0 ;
9535 char * kwnames[] = {
9536 (char *) "self",(char *) "obj", NULL
9537 };
9538
9539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9541 if (!SWIG_IsOK(res1)) {
9542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9543 }
9544 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9545 arg2 = obj1;
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 wxOutputStream_write(arg1,arg2);
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9560 PyObject *resultobj = 0;
9561 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9562 size_t result;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 PyObject *swig_obj[1] ;
9566
9567 if (!args) SWIG_fail;
9568 swig_obj[0] = args;
9569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9572 }
9573 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9574 {
9575 PyThreadState* __tstate = wxPyBeginAllowThreads();
9576 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9588 PyObject *obj;
9589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9590 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9591 return SWIG_Py_Void();
9592 }
9593
9594 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj = 0;
9596 wxInputStream *arg1 = (wxInputStream *) 0 ;
9597 wxString *arg2 = 0 ;
9598 wxString *arg3 = 0 ;
9599 wxString *arg4 = 0 ;
9600 wxDateTime arg5 ;
9601 wxFSFile *result = 0 ;
9602 wxPyInputStream *temp1 ;
9603 bool temp2 = false ;
9604 bool temp3 = false ;
9605 bool temp4 = false ;
9606 void *argp5 ;
9607 int res5 = 0 ;
9608 PyObject * obj0 = 0 ;
9609 PyObject * obj1 = 0 ;
9610 PyObject * obj2 = 0 ;
9611 PyObject * obj3 = 0 ;
9612 PyObject * obj4 = 0 ;
9613 char * kwnames[] = {
9614 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9615 };
9616
9617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9618 {
9619 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9620 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9621 } else {
9622 PyErr_Clear(); // clear the failure of the wxPyConvert above
9623 arg1 = wxPyCBInputStream_create(obj0, true);
9624 if (arg1 == NULL) {
9625 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9626 SWIG_fail;
9627 }
9628 }
9629 }
9630 {
9631 arg2 = wxString_in_helper(obj1);
9632 if (arg2 == NULL) SWIG_fail;
9633 temp2 = true;
9634 }
9635 {
9636 arg3 = wxString_in_helper(obj2);
9637 if (arg3 == NULL) SWIG_fail;
9638 temp3 = true;
9639 }
9640 {
9641 arg4 = wxString_in_helper(obj3);
9642 if (arg4 == NULL) SWIG_fail;
9643 temp4 = true;
9644 }
9645 {
9646 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9647 if (!SWIG_IsOK(res5)) {
9648 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9649 }
9650 if (!argp5) {
9651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9652 } else {
9653 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9654 arg5 = *temp;
9655 if (SWIG_IsNewObj(res5)) delete temp;
9656 }
9657 }
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9665 {
9666 if (temp2)
9667 delete arg2;
9668 }
9669 {
9670 if (temp3)
9671 delete arg3;
9672 }
9673 {
9674 if (temp4)
9675 delete arg4;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp2)
9681 delete arg2;
9682 }
9683 {
9684 if (temp3)
9685 delete arg3;
9686 }
9687 {
9688 if (temp4)
9689 delete arg4;
9690 }
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696 PyObject *resultobj = 0;
9697 wxFSFile *arg1 = (wxFSFile *) 0 ;
9698 void *argp1 = 0 ;
9699 int res1 = 0 ;
9700 PyObject *swig_obj[1] ;
9701
9702 if (!args) SWIG_fail;
9703 swig_obj[0] = args;
9704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9705 if (!SWIG_IsOK(res1)) {
9706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9707 }
9708 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 delete arg1;
9712
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 resultobj = SWIG_Py_Void();
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9724 PyObject *resultobj = 0;
9725 wxFSFile *arg1 = (wxFSFile *) 0 ;
9726 wxInputStream *result = 0 ;
9727 void *argp1 = 0 ;
9728 int res1 = 0 ;
9729 PyObject *swig_obj[1] ;
9730
9731 if (!args) SWIG_fail;
9732 swig_obj[0] = args;
9733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9734 if (!SWIG_IsOK(res1)) {
9735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9736 }
9737 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 result = (wxInputStream *)(arg1)->GetStream();
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 {
9745 wxPyInputStream * _ptr = NULL;
9746
9747 if (result) {
9748 _ptr = new wxPyInputStream(result);
9749 }
9750 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9751 }
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9759 PyObject *resultobj = 0;
9760 wxFSFile *arg1 = (wxFSFile *) 0 ;
9761 wxString *result = 0 ;
9762 void *argp1 = 0 ;
9763 int res1 = 0 ;
9764 PyObject *swig_obj[1] ;
9765
9766 if (!args) SWIG_fail;
9767 swig_obj[0] = args;
9768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9769 if (!SWIG_IsOK(res1)) {
9770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9771 }
9772 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9773 {
9774 PyThreadState* __tstate = wxPyBeginAllowThreads();
9775 {
9776 wxString const &_result_ref = (arg1)->GetMimeType();
9777 result = (wxString *) &_result_ref;
9778 }
9779 wxPyEndAllowThreads(__tstate);
9780 if (PyErr_Occurred()) SWIG_fail;
9781 }
9782 {
9783 #if wxUSE_UNICODE
9784 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9785 #else
9786 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9787 #endif
9788 }
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9796 PyObject *resultobj = 0;
9797 wxFSFile *arg1 = (wxFSFile *) 0 ;
9798 wxString *result = 0 ;
9799 void *argp1 = 0 ;
9800 int res1 = 0 ;
9801 PyObject *swig_obj[1] ;
9802
9803 if (!args) SWIG_fail;
9804 swig_obj[0] = args;
9805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9806 if (!SWIG_IsOK(res1)) {
9807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9808 }
9809 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 {
9813 wxString const &_result_ref = (arg1)->GetLocation();
9814 result = (wxString *) &_result_ref;
9815 }
9816 wxPyEndAllowThreads(__tstate);
9817 if (PyErr_Occurred()) SWIG_fail;
9818 }
9819 {
9820 #if wxUSE_UNICODE
9821 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9822 #else
9823 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9824 #endif
9825 }
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9833 PyObject *resultobj = 0;
9834 wxFSFile *arg1 = (wxFSFile *) 0 ;
9835 wxString *result = 0 ;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 PyObject *swig_obj[1] ;
9839
9840 if (!args) SWIG_fail;
9841 swig_obj[0] = args;
9842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9843 if (!SWIG_IsOK(res1)) {
9844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9845 }
9846 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 {
9850 wxString const &_result_ref = (arg1)->GetAnchor();
9851 result = (wxString *) &_result_ref;
9852 }
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 {
9857 #if wxUSE_UNICODE
9858 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9859 #else
9860 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9861 #endif
9862 }
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9870 PyObject *resultobj = 0;
9871 wxFSFile *arg1 = (wxFSFile *) 0 ;
9872 wxDateTime result;
9873 void *argp1 = 0 ;
9874 int res1 = 0 ;
9875 PyObject *swig_obj[1] ;
9876
9877 if (!args) SWIG_fail;
9878 swig_obj[0] = args;
9879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9880 if (!SWIG_IsOK(res1)) {
9881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9882 }
9883 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (arg1)->GetModificationTime();
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *obj;
9899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9900 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9901 return SWIG_Py_Void();
9902 }
9903
9904 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9905 return SWIG_Python_InitShadowInstance(args);
9906 }
9907
9908 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9909 PyObject *resultobj = 0;
9910 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9911 void *argp1 = 0 ;
9912 int res1 = 0 ;
9913 PyObject *swig_obj[1] ;
9914
9915 if (!args) SWIG_fail;
9916 swig_obj[0] = args;
9917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9918 if (!SWIG_IsOK(res1)) {
9919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9920 }
9921 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 delete arg1;
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 resultobj = SWIG_Py_Void();
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9937 PyObject *obj;
9938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9939 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9940 return SWIG_Py_Void();
9941 }
9942
9943 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9944 PyObject *resultobj = 0;
9945 wxPyFileSystemHandler *result = 0 ;
9946
9947 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj = 0;
9963 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9964 PyObject *arg2 = (PyObject *) 0 ;
9965 PyObject *arg3 = (PyObject *) 0 ;
9966 void *argp1 = 0 ;
9967 int res1 = 0 ;
9968 PyObject * obj0 = 0 ;
9969 PyObject * obj1 = 0 ;
9970 PyObject * obj2 = 0 ;
9971 char * kwnames[] = {
9972 (char *) "self",(char *) "self",(char *) "_class", NULL
9973 };
9974
9975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9977 if (!SWIG_IsOK(res1)) {
9978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9979 }
9980 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9981 arg2 = obj1;
9982 arg3 = obj2;
9983 {
9984 PyThreadState* __tstate = wxPyBeginAllowThreads();
9985 (arg1)->_setCallbackInfo(arg2,arg3);
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 resultobj = SWIG_Py_Void();
9990 return resultobj;
9991 fail:
9992 return NULL;
9993 }
9994
9995
9996 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9997 PyObject *resultobj = 0;
9998 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9999 wxString *arg2 = 0 ;
10000 bool result;
10001 void *argp1 = 0 ;
10002 int res1 = 0 ;
10003 bool temp2 = false ;
10004 PyObject * obj0 = 0 ;
10005 PyObject * obj1 = 0 ;
10006 char * kwnames[] = {
10007 (char *) "self",(char *) "location", NULL
10008 };
10009
10010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10012 if (!SWIG_IsOK(res1)) {
10013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10014 }
10015 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10016 {
10017 arg2 = wxString_in_helper(obj1);
10018 if (arg2 == NULL) SWIG_fail;
10019 temp2 = true;
10020 }
10021 {
10022 PyThreadState* __tstate = wxPyBeginAllowThreads();
10023 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10024 wxPyEndAllowThreads(__tstate);
10025 if (PyErr_Occurred()) SWIG_fail;
10026 }
10027 {
10028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10029 }
10030 {
10031 if (temp2)
10032 delete arg2;
10033 }
10034 return resultobj;
10035 fail:
10036 {
10037 if (temp2)
10038 delete arg2;
10039 }
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10047 wxFileSystem *arg2 = 0 ;
10048 wxString *arg3 = 0 ;
10049 wxFSFile *result = 0 ;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 void *argp2 = 0 ;
10053 int res2 = 0 ;
10054 bool temp3 = false ;
10055 PyObject * obj0 = 0 ;
10056 PyObject * obj1 = 0 ;
10057 PyObject * obj2 = 0 ;
10058 char * kwnames[] = {
10059 (char *) "self",(char *) "fs",(char *) "location", NULL
10060 };
10061
10062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10066 }
10067 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10069 if (!SWIG_IsOK(res2)) {
10070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10071 }
10072 if (!argp2) {
10073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10074 }
10075 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10076 {
10077 arg3 = wxString_in_helper(obj2);
10078 if (arg3 == NULL) SWIG_fail;
10079 temp3 = true;
10080 }
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 {
10088 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10089 }
10090 {
10091 if (temp3)
10092 delete arg3;
10093 }
10094 return resultobj;
10095 fail:
10096 {
10097 if (temp3)
10098 delete arg3;
10099 }
10100 return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj = 0;
10106 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10107 wxString *arg2 = 0 ;
10108 int arg3 = (int) 0 ;
10109 wxString result;
10110 void *argp1 = 0 ;
10111 int res1 = 0 ;
10112 bool temp2 = false ;
10113 int val3 ;
10114 int ecode3 = 0 ;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 PyObject * obj2 = 0 ;
10118 char * kwnames[] = {
10119 (char *) "self",(char *) "spec",(char *) "flags", NULL
10120 };
10121
10122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10124 if (!SWIG_IsOK(res1)) {
10125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10126 }
10127 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10128 {
10129 arg2 = wxString_in_helper(obj1);
10130 if (arg2 == NULL) SWIG_fail;
10131 temp2 = true;
10132 }
10133 if (obj2) {
10134 ecode3 = SWIG_AsVal_int(obj2, &val3);
10135 if (!SWIG_IsOK(ecode3)) {
10136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10137 }
10138 arg3 = static_cast< int >(val3);
10139 }
10140 {
10141 PyThreadState* __tstate = wxPyBeginAllowThreads();
10142 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 {
10147 #if wxUSE_UNICODE
10148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10149 #else
10150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10151 #endif
10152 }
10153 {
10154 if (temp2)
10155 delete arg2;
10156 }
10157 return resultobj;
10158 fail:
10159 {
10160 if (temp2)
10161 delete arg2;
10162 }
10163 return NULL;
10164 }
10165
10166
10167 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10168 PyObject *resultobj = 0;
10169 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10170 wxString result;
10171 void *argp1 = 0 ;
10172 int res1 = 0 ;
10173 PyObject *swig_obj[1] ;
10174
10175 if (!args) SWIG_fail;
10176 swig_obj[0] = args;
10177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10180 }
10181 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10182 {
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 result = (arg1)->FindNext();
10185 wxPyEndAllowThreads(__tstate);
10186 if (PyErr_Occurred()) SWIG_fail;
10187 }
10188 {
10189 #if wxUSE_UNICODE
10190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10191 #else
10192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10193 #endif
10194 }
10195 return resultobj;
10196 fail:
10197 return NULL;
10198 }
10199
10200
10201 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10202 PyObject *resultobj = 0;
10203 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10204 wxString *arg2 = 0 ;
10205 wxString result;
10206 void *argp1 = 0 ;
10207 int res1 = 0 ;
10208 bool temp2 = false ;
10209 PyObject * obj0 = 0 ;
10210 PyObject * obj1 = 0 ;
10211 char * kwnames[] = {
10212 (char *) "self",(char *) "location", NULL
10213 };
10214
10215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10217 if (!SWIG_IsOK(res1)) {
10218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10219 }
10220 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10221 {
10222 arg2 = wxString_in_helper(obj1);
10223 if (arg2 == NULL) SWIG_fail;
10224 temp2 = true;
10225 }
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (arg1)->GetProtocol((wxString const &)*arg2);
10229 wxPyEndAllowThreads(__tstate);
10230 if (PyErr_Occurred()) SWIG_fail;
10231 }
10232 {
10233 #if wxUSE_UNICODE
10234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10235 #else
10236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10237 #endif
10238 }
10239 {
10240 if (temp2)
10241 delete arg2;
10242 }
10243 return resultobj;
10244 fail:
10245 {
10246 if (temp2)
10247 delete arg2;
10248 }
10249 return NULL;
10250 }
10251
10252
10253 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj = 0;
10255 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10256 wxString *arg2 = 0 ;
10257 wxString result;
10258 void *argp1 = 0 ;
10259 int res1 = 0 ;
10260 bool temp2 = false ;
10261 PyObject * obj0 = 0 ;
10262 PyObject * obj1 = 0 ;
10263 char * kwnames[] = {
10264 (char *) "self",(char *) "location", NULL
10265 };
10266
10267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10271 }
10272 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10273 {
10274 arg2 = wxString_in_helper(obj1);
10275 if (arg2 == NULL) SWIG_fail;
10276 temp2 = true;
10277 }
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 {
10285 #if wxUSE_UNICODE
10286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10287 #else
10288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10289 #endif
10290 }
10291 {
10292 if (temp2)
10293 delete arg2;
10294 }
10295 return resultobj;
10296 fail:
10297 {
10298 if (temp2)
10299 delete arg2;
10300 }
10301 return NULL;
10302 }
10303
10304
10305 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10306 PyObject *resultobj = 0;
10307 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10308 wxString *arg2 = 0 ;
10309 wxString result;
10310 void *argp1 = 0 ;
10311 int res1 = 0 ;
10312 bool temp2 = false ;
10313 PyObject * obj0 = 0 ;
10314 PyObject * obj1 = 0 ;
10315 char * kwnames[] = {
10316 (char *) "self",(char *) "location", NULL
10317 };
10318
10319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10321 if (!SWIG_IsOK(res1)) {
10322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10323 }
10324 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10325 {
10326 arg2 = wxString_in_helper(obj1);
10327 if (arg2 == NULL) SWIG_fail;
10328 temp2 = true;
10329 }
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (arg1)->GetAnchor((wxString const &)*arg2);
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 {
10337 #if wxUSE_UNICODE
10338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10339 #else
10340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10341 #endif
10342 }
10343 {
10344 if (temp2)
10345 delete arg2;
10346 }
10347 return resultobj;
10348 fail:
10349 {
10350 if (temp2)
10351 delete arg2;
10352 }
10353 return NULL;
10354 }
10355
10356
10357 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10358 PyObject *resultobj = 0;
10359 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10360 wxString *arg2 = 0 ;
10361 wxString result;
10362 void *argp1 = 0 ;
10363 int res1 = 0 ;
10364 bool temp2 = false ;
10365 PyObject * obj0 = 0 ;
10366 PyObject * obj1 = 0 ;
10367 char * kwnames[] = {
10368 (char *) "self",(char *) "location", NULL
10369 };
10370
10371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10373 if (!SWIG_IsOK(res1)) {
10374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10375 }
10376 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10377 {
10378 arg2 = wxString_in_helper(obj1);
10379 if (arg2 == NULL) SWIG_fail;
10380 temp2 = true;
10381 }
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 #if wxUSE_UNICODE
10390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10391 #else
10392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10393 #endif
10394 }
10395 {
10396 if (temp2)
10397 delete arg2;
10398 }
10399 return resultobj;
10400 fail:
10401 {
10402 if (temp2)
10403 delete arg2;
10404 }
10405 return NULL;
10406 }
10407
10408
10409 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10410 PyObject *resultobj = 0;
10411 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10412 wxString *arg2 = 0 ;
10413 wxString result;
10414 void *argp1 = 0 ;
10415 int res1 = 0 ;
10416 bool temp2 = false ;
10417 PyObject * obj0 = 0 ;
10418 PyObject * obj1 = 0 ;
10419 char * kwnames[] = {
10420 (char *) "self",(char *) "location", NULL
10421 };
10422
10423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10425 if (!SWIG_IsOK(res1)) {
10426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10427 }
10428 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10429 {
10430 arg2 = wxString_in_helper(obj1);
10431 if (arg2 == NULL) SWIG_fail;
10432 temp2 = true;
10433 }
10434 {
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 {
10441 #if wxUSE_UNICODE
10442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10443 #else
10444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10445 #endif
10446 }
10447 {
10448 if (temp2)
10449 delete arg2;
10450 }
10451 return resultobj;
10452 fail:
10453 {
10454 if (temp2)
10455 delete arg2;
10456 }
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *obj;
10463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10464 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10465 return SWIG_Py_Void();
10466 }
10467
10468 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10469 return SWIG_Python_InitShadowInstance(args);
10470 }
10471
10472 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10473 PyObject *resultobj = 0;
10474 wxFileSystem *result = 0 ;
10475
10476 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxFileSystem *)new wxFileSystem();
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10493 PyObject *resultobj = 0;
10494 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 PyObject *swig_obj[1] ;
10498
10499 if (!args) SWIG_fail;
10500 swig_obj[0] = args;
10501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10502 if (!SWIG_IsOK(res1)) {
10503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10504 }
10505 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 delete arg1;
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_Py_Void();
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10521 PyObject *resultobj = 0;
10522 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10523 wxString *arg2 = 0 ;
10524 bool arg3 = (bool) false ;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 bool temp2 = false ;
10528 bool val3 ;
10529 int ecode3 = 0 ;
10530 PyObject * obj0 = 0 ;
10531 PyObject * obj1 = 0 ;
10532 PyObject * obj2 = 0 ;
10533 char * kwnames[] = {
10534 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10535 };
10536
10537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10539 if (!SWIG_IsOK(res1)) {
10540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10541 }
10542 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10543 {
10544 arg2 = wxString_in_helper(obj1);
10545 if (arg2 == NULL) SWIG_fail;
10546 temp2 = true;
10547 }
10548 if (obj2) {
10549 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10550 if (!SWIG_IsOK(ecode3)) {
10551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10552 }
10553 arg3 = static_cast< bool >(val3);
10554 }
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_Py_Void();
10562 {
10563 if (temp2)
10564 delete arg2;
10565 }
10566 return resultobj;
10567 fail:
10568 {
10569 if (temp2)
10570 delete arg2;
10571 }
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10579 wxString result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10589 }
10590 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (arg1)->GetPath();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 #if wxUSE_UNICODE
10599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10600 #else
10601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10602 #endif
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10611 PyObject *resultobj = 0;
10612 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10613 wxString *arg2 = 0 ;
10614 wxFSFile *result = 0 ;
10615 void *argp1 = 0 ;
10616 int res1 = 0 ;
10617 bool temp2 = false ;
10618 PyObject * obj0 = 0 ;
10619 PyObject * obj1 = 0 ;
10620 char * kwnames[] = {
10621 (char *) "self",(char *) "location", NULL
10622 };
10623
10624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10626 if (!SWIG_IsOK(res1)) {
10627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10628 }
10629 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10630 {
10631 arg2 = wxString_in_helper(obj1);
10632 if (arg2 == NULL) SWIG_fail;
10633 temp2 = true;
10634 }
10635 {
10636 PyThreadState* __tstate = wxPyBeginAllowThreads();
10637 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 {
10642 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10643 }
10644 {
10645 if (temp2)
10646 delete arg2;
10647 }
10648 return resultobj;
10649 fail:
10650 {
10651 if (temp2)
10652 delete arg2;
10653 }
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10659 PyObject *resultobj = 0;
10660 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10661 wxString *arg2 = 0 ;
10662 int arg3 = (int) 0 ;
10663 wxString result;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 bool temp2 = false ;
10667 int val3 ;
10668 int ecode3 = 0 ;
10669 PyObject * obj0 = 0 ;
10670 PyObject * obj1 = 0 ;
10671 PyObject * obj2 = 0 ;
10672 char * kwnames[] = {
10673 (char *) "self",(char *) "spec",(char *) "flags", NULL
10674 };
10675
10676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10678 if (!SWIG_IsOK(res1)) {
10679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10680 }
10681 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10682 {
10683 arg2 = wxString_in_helper(obj1);
10684 if (arg2 == NULL) SWIG_fail;
10685 temp2 = true;
10686 }
10687 if (obj2) {
10688 ecode3 = SWIG_AsVal_int(obj2, &val3);
10689 if (!SWIG_IsOK(ecode3)) {
10690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10691 }
10692 arg3 = static_cast< int >(val3);
10693 }
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 {
10701 #if wxUSE_UNICODE
10702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10703 #else
10704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10705 #endif
10706 }
10707 {
10708 if (temp2)
10709 delete arg2;
10710 }
10711 return resultobj;
10712 fail:
10713 {
10714 if (temp2)
10715 delete arg2;
10716 }
10717 return NULL;
10718 }
10719
10720
10721 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10722 PyObject *resultobj = 0;
10723 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10724 wxString result;
10725 void *argp1 = 0 ;
10726 int res1 = 0 ;
10727 PyObject *swig_obj[1] ;
10728
10729 if (!args) SWIG_fail;
10730 swig_obj[0] = args;
10731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10732 if (!SWIG_IsOK(res1)) {
10733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10734 }
10735 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10736 {
10737 PyThreadState* __tstate = wxPyBeginAllowThreads();
10738 result = (arg1)->FindNext();
10739 wxPyEndAllowThreads(__tstate);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 {
10743 #if wxUSE_UNICODE
10744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10745 #else
10746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10747 #endif
10748 }
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj = 0;
10757 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10758 int res1 = 0 ;
10759 PyObject * obj0 = 0 ;
10760 char * kwnames[] = {
10761 (char *) "handler", NULL
10762 };
10763
10764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10765 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10766 if (!SWIG_IsOK(res1)) {
10767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10768 }
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 wxFileSystem::AddHandler(arg1);
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 resultobj = SWIG_Py_Void();
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10783 PyObject *resultobj = 0;
10784
10785 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10786 {
10787 PyThreadState* __tstate = wxPyBeginAllowThreads();
10788 wxFileSystem::CleanUpHandlers();
10789 wxPyEndAllowThreads(__tstate);
10790 if (PyErr_Occurred()) SWIG_fail;
10791 }
10792 resultobj = SWIG_Py_Void();
10793 return resultobj;
10794 fail:
10795 return NULL;
10796 }
10797
10798
10799 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj = 0;
10801 wxString *arg1 = 0 ;
10802 wxString result;
10803 bool temp1 = false ;
10804 PyObject * obj0 = 0 ;
10805 char * kwnames[] = {
10806 (char *) "filename", NULL
10807 };
10808
10809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10810 {
10811 arg1 = wxString_in_helper(obj0);
10812 if (arg1 == NULL) SWIG_fail;
10813 temp1 = true;
10814 }
10815 {
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10818 wxPyEndAllowThreads(__tstate);
10819 if (PyErr_Occurred()) SWIG_fail;
10820 }
10821 {
10822 #if wxUSE_UNICODE
10823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10824 #else
10825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10826 #endif
10827 }
10828 {
10829 if (temp1)
10830 delete arg1;
10831 }
10832 return resultobj;
10833 fail:
10834 {
10835 if (temp1)
10836 delete arg1;
10837 }
10838 return NULL;
10839 }
10840
10841
10842 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj = 0;
10844 wxString *arg1 = 0 ;
10845 wxString result;
10846 bool temp1 = false ;
10847 PyObject * obj0 = 0 ;
10848 char * kwnames[] = {
10849 (char *) "url", NULL
10850 };
10851
10852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10853 {
10854 arg1 = wxString_in_helper(obj0);
10855 if (arg1 == NULL) SWIG_fail;
10856 temp1 = true;
10857 }
10858 {
10859 PyThreadState* __tstate = wxPyBeginAllowThreads();
10860 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10861 wxPyEndAllowThreads(__tstate);
10862 if (PyErr_Occurred()) SWIG_fail;
10863 }
10864 {
10865 #if wxUSE_UNICODE
10866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10867 #else
10868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10869 #endif
10870 }
10871 {
10872 if (temp1)
10873 delete arg1;
10874 }
10875 return resultobj;
10876 fail:
10877 {
10878 if (temp1)
10879 delete arg1;
10880 }
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 PyObject *obj;
10887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10888 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10889 return SWIG_Py_Void();
10890 }
10891
10892 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10893 return SWIG_Python_InitShadowInstance(args);
10894 }
10895
10896 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10897 PyObject *resultobj = 0;
10898 wxInternetFSHandler *result = 0 ;
10899
10900 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10917 wxString *arg2 = 0 ;
10918 bool result;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 bool temp2 = false ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "self",(char *) "location", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10932 }
10933 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10934 {
10935 arg2 = wxString_in_helper(obj1);
10936 if (arg2 == NULL) SWIG_fail;
10937 temp2 = true;
10938 }
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 {
10946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10947 }
10948 {
10949 if (temp2)
10950 delete arg2;
10951 }
10952 return resultobj;
10953 fail:
10954 {
10955 if (temp2)
10956 delete arg2;
10957 }
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = 0;
10964 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10965 wxFileSystem *arg2 = 0 ;
10966 wxString *arg3 = 0 ;
10967 wxFSFile *result = 0 ;
10968 void *argp1 = 0 ;
10969 int res1 = 0 ;
10970 void *argp2 = 0 ;
10971 int res2 = 0 ;
10972 bool temp3 = false ;
10973 PyObject * obj0 = 0 ;
10974 PyObject * obj1 = 0 ;
10975 PyObject * obj2 = 0 ;
10976 char * kwnames[] = {
10977 (char *) "self",(char *) "fs",(char *) "location", NULL
10978 };
10979
10980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10982 if (!SWIG_IsOK(res1)) {
10983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10984 }
10985 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10987 if (!SWIG_IsOK(res2)) {
10988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10989 }
10990 if (!argp2) {
10991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10992 }
10993 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10994 {
10995 arg3 = wxString_in_helper(obj2);
10996 if (arg3 == NULL) SWIG_fail;
10997 temp3 = true;
10998 }
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11007 }
11008 {
11009 if (temp3)
11010 delete arg3;
11011 }
11012 return resultobj;
11013 fail:
11014 {
11015 if (temp3)
11016 delete arg3;
11017 }
11018 return NULL;
11019 }
11020
11021
11022 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 PyObject *obj;
11024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11025 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11026 return SWIG_Py_Void();
11027 }
11028
11029 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11030 return SWIG_Python_InitShadowInstance(args);
11031 }
11032
11033 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11034 PyObject *resultobj = 0;
11035 wxZipFSHandler *result = 0 ;
11036
11037 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (wxZipFSHandler *)new wxZipFSHandler();
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11045 return resultobj;
11046 fail:
11047 return NULL;
11048 }
11049
11050
11051 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11052 PyObject *resultobj = 0;
11053 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11054 wxString *arg2 = 0 ;
11055 bool result;
11056 void *argp1 = 0 ;
11057 int res1 = 0 ;
11058 bool temp2 = false ;
11059 PyObject * obj0 = 0 ;
11060 PyObject * obj1 = 0 ;
11061 char * kwnames[] = {
11062 (char *) "self",(char *) "location", NULL
11063 };
11064
11065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11069 }
11070 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11071 {
11072 arg2 = wxString_in_helper(obj1);
11073 if (arg2 == NULL) SWIG_fail;
11074 temp2 = true;
11075 }
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 {
11083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11084 }
11085 {
11086 if (temp2)
11087 delete arg2;
11088 }
11089 return resultobj;
11090 fail:
11091 {
11092 if (temp2)
11093 delete arg2;
11094 }
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj = 0;
11101 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11102 wxFileSystem *arg2 = 0 ;
11103 wxString *arg3 = 0 ;
11104 wxFSFile *result = 0 ;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 void *argp2 = 0 ;
11108 int res2 = 0 ;
11109 bool temp3 = false ;
11110 PyObject * obj0 = 0 ;
11111 PyObject * obj1 = 0 ;
11112 PyObject * obj2 = 0 ;
11113 char * kwnames[] = {
11114 (char *) "self",(char *) "fs",(char *) "location", NULL
11115 };
11116
11117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11119 if (!SWIG_IsOK(res1)) {
11120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11121 }
11122 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11124 if (!SWIG_IsOK(res2)) {
11125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11126 }
11127 if (!argp2) {
11128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11129 }
11130 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11131 {
11132 arg3 = wxString_in_helper(obj2);
11133 if (arg3 == NULL) SWIG_fail;
11134 temp3 = true;
11135 }
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 {
11143 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11144 }
11145 {
11146 if (temp3)
11147 delete arg3;
11148 }
11149 return resultobj;
11150 fail:
11151 {
11152 if (temp3)
11153 delete arg3;
11154 }
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11160 PyObject *resultobj = 0;
11161 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11162 wxString *arg2 = 0 ;
11163 int arg3 = (int) 0 ;
11164 wxString result;
11165 void *argp1 = 0 ;
11166 int res1 = 0 ;
11167 bool temp2 = false ;
11168 int val3 ;
11169 int ecode3 = 0 ;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 char * kwnames[] = {
11174 (char *) "self",(char *) "spec",(char *) "flags", NULL
11175 };
11176
11177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11179 if (!SWIG_IsOK(res1)) {
11180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11181 }
11182 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11183 {
11184 arg2 = wxString_in_helper(obj1);
11185 if (arg2 == NULL) SWIG_fail;
11186 temp2 = true;
11187 }
11188 if (obj2) {
11189 ecode3 = SWIG_AsVal_int(obj2, &val3);
11190 if (!SWIG_IsOK(ecode3)) {
11191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11192 }
11193 arg3 = static_cast< int >(val3);
11194 }
11195 {
11196 PyThreadState* __tstate = wxPyBeginAllowThreads();
11197 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11198 wxPyEndAllowThreads(__tstate);
11199 if (PyErr_Occurred()) SWIG_fail;
11200 }
11201 {
11202 #if wxUSE_UNICODE
11203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11204 #else
11205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11206 #endif
11207 }
11208 {
11209 if (temp2)
11210 delete arg2;
11211 }
11212 return resultobj;
11213 fail:
11214 {
11215 if (temp2)
11216 delete arg2;
11217 }
11218 return NULL;
11219 }
11220
11221
11222 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11223 PyObject *resultobj = 0;
11224 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11225 wxString result;
11226 void *argp1 = 0 ;
11227 int res1 = 0 ;
11228 PyObject *swig_obj[1] ;
11229
11230 if (!args) SWIG_fail;
11231 swig_obj[0] = args;
11232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11233 if (!SWIG_IsOK(res1)) {
11234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11235 }
11236 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11237 {
11238 PyThreadState* __tstate = wxPyBeginAllowThreads();
11239 result = (arg1)->FindNext();
11240 wxPyEndAllowThreads(__tstate);
11241 if (PyErr_Occurred()) SWIG_fail;
11242 }
11243 {
11244 #if wxUSE_UNICODE
11245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11246 #else
11247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11248 #endif
11249 }
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *obj;
11258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11259 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11260 return SWIG_Py_Void();
11261 }
11262
11263 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11264 return SWIG_Python_InitShadowInstance(args);
11265 }
11266
11267 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11268 PyObject *resultobj = 0;
11269 wxString *arg1 = 0 ;
11270 wxImage *arg2 = 0 ;
11271 long arg3 ;
11272 bool temp1 = false ;
11273 void *argp2 = 0 ;
11274 int res2 = 0 ;
11275 long val3 ;
11276 int ecode3 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 char * kwnames[] = {
11281 (char *) "filename",(char *) "image",(char *) "type", NULL
11282 };
11283
11284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11285 {
11286 arg1 = wxString_in_helper(obj0);
11287 if (arg1 == NULL) SWIG_fail;
11288 temp1 = true;
11289 }
11290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11291 if (!SWIG_IsOK(res2)) {
11292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11293 }
11294 if (!argp2) {
11295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11296 }
11297 arg2 = reinterpret_cast< wxImage * >(argp2);
11298 ecode3 = SWIG_AsVal_long(obj2, &val3);
11299 if (!SWIG_IsOK(ecode3)) {
11300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11301 }
11302 arg3 = static_cast< long >(val3);
11303 {
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 resultobj = SWIG_Py_Void();
11310 {
11311 if (temp1)
11312 delete arg1;
11313 }
11314 return resultobj;
11315 fail:
11316 {
11317 if (temp1)
11318 delete arg1;
11319 }
11320 return NULL;
11321 }
11322
11323
11324 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11325 PyObject *resultobj = 0;
11326 wxString *arg1 = 0 ;
11327 wxBitmap *arg2 = 0 ;
11328 long arg3 ;
11329 bool temp1 = false ;
11330 void *argp2 = 0 ;
11331 int res2 = 0 ;
11332 long val3 ;
11333 int ecode3 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11342 {
11343 arg1 = wxString_in_helper(obj0);
11344 if (arg1 == NULL) SWIG_fail;
11345 temp1 = true;
11346 }
11347 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11348 if (!SWIG_IsOK(res2)) {
11349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11350 }
11351 if (!argp2) {
11352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11353 }
11354 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11355 ecode3 = SWIG_AsVal_long(obj2, &val3);
11356 if (!SWIG_IsOK(ecode3)) {
11357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11358 }
11359 arg3 = static_cast< long >(val3);
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 resultobj = SWIG_Py_Void();
11367 {
11368 if (temp1)
11369 delete arg1;
11370 }
11371 return resultobj;
11372 fail:
11373 {
11374 if (temp1)
11375 delete arg1;
11376 }
11377 return NULL;
11378 }
11379
11380
11381 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11382 PyObject *resultobj = 0;
11383 wxString *arg1 = 0 ;
11384 PyObject *arg2 = (PyObject *) 0 ;
11385 bool temp1 = false ;
11386 PyObject * obj0 = 0 ;
11387 PyObject * obj1 = 0 ;
11388 char * kwnames[] = {
11389 (char *) "filename",(char *) "data", NULL
11390 };
11391
11392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11393 {
11394 arg1 = wxString_in_helper(obj0);
11395 if (arg1 == NULL) SWIG_fail;
11396 temp1 = true;
11397 }
11398 arg2 = obj1;
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 resultobj = SWIG_Py_Void();
11406 {
11407 if (temp1)
11408 delete arg1;
11409 }
11410 return resultobj;
11411 fail:
11412 {
11413 if (temp1)
11414 delete arg1;
11415 }
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *resultobj = 0;
11422 wxMemoryFSHandler *result = 0 ;
11423
11424 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj = 0;
11440 wxString *arg1 = 0 ;
11441 bool temp1 = false ;
11442 PyObject * obj0 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "filename", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11448 {
11449 arg1 = wxString_in_helper(obj0);
11450 if (arg1 == NULL) SWIG_fail;
11451 temp1 = true;
11452 }
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_Py_Void();
11460 {
11461 if (temp1)
11462 delete arg1;
11463 }
11464 return resultobj;
11465 fail:
11466 {
11467 if (temp1)
11468 delete arg1;
11469 }
11470 return NULL;
11471 }
11472
11473
11474 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11475 PyObject *resultobj = 0;
11476 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11477 wxString *arg2 = 0 ;
11478 bool result;
11479 void *argp1 = 0 ;
11480 int res1 = 0 ;
11481 bool temp2 = false ;
11482 PyObject * obj0 = 0 ;
11483 PyObject * obj1 = 0 ;
11484 char * kwnames[] = {
11485 (char *) "self",(char *) "location", NULL
11486 };
11487
11488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11492 }
11493 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11494 {
11495 arg2 = wxString_in_helper(obj1);
11496 if (arg2 == NULL) SWIG_fail;
11497 temp2 = true;
11498 }
11499 {
11500 PyThreadState* __tstate = wxPyBeginAllowThreads();
11501 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11507 }
11508 {
11509 if (temp2)
11510 delete arg2;
11511 }
11512 return resultobj;
11513 fail:
11514 {
11515 if (temp2)
11516 delete arg2;
11517 }
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11525 wxFileSystem *arg2 = 0 ;
11526 wxString *arg3 = 0 ;
11527 wxFSFile *result = 0 ;
11528 void *argp1 = 0 ;
11529 int res1 = 0 ;
11530 void *argp2 = 0 ;
11531 int res2 = 0 ;
11532 bool temp3 = false ;
11533 PyObject * obj0 = 0 ;
11534 PyObject * obj1 = 0 ;
11535 PyObject * obj2 = 0 ;
11536 char * kwnames[] = {
11537 (char *) "self",(char *) "fs",(char *) "location", NULL
11538 };
11539
11540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11542 if (!SWIG_IsOK(res1)) {
11543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11544 }
11545 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11547 if (!SWIG_IsOK(res2)) {
11548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11549 }
11550 if (!argp2) {
11551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11552 }
11553 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11554 {
11555 arg3 = wxString_in_helper(obj2);
11556 if (arg3 == NULL) SWIG_fail;
11557 temp3 = true;
11558 }
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11567 }
11568 {
11569 if (temp3)
11570 delete arg3;
11571 }
11572 return resultobj;
11573 fail:
11574 {
11575 if (temp3)
11576 delete arg3;
11577 }
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = 0;
11584 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11585 wxString *arg2 = 0 ;
11586 int arg3 = (int) 0 ;
11587 wxString result;
11588 void *argp1 = 0 ;
11589 int res1 = 0 ;
11590 bool temp2 = false ;
11591 int val3 ;
11592 int ecode3 = 0 ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 PyObject * obj2 = 0 ;
11596 char * kwnames[] = {
11597 (char *) "self",(char *) "spec",(char *) "flags", NULL
11598 };
11599
11600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11604 }
11605 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11606 {
11607 arg2 = wxString_in_helper(obj1);
11608 if (arg2 == NULL) SWIG_fail;
11609 temp2 = true;
11610 }
11611 if (obj2) {
11612 ecode3 = SWIG_AsVal_int(obj2, &val3);
11613 if (!SWIG_IsOK(ecode3)) {
11614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11615 }
11616 arg3 = static_cast< int >(val3);
11617 }
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 #if wxUSE_UNICODE
11626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11627 #else
11628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11629 #endif
11630 }
11631 {
11632 if (temp2)
11633 delete arg2;
11634 }
11635 return resultobj;
11636 fail:
11637 {
11638 if (temp2)
11639 delete arg2;
11640 }
11641 return NULL;
11642 }
11643
11644
11645 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646 PyObject *resultobj = 0;
11647 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11648 wxString result;
11649 void *argp1 = 0 ;
11650 int res1 = 0 ;
11651 PyObject *swig_obj[1] ;
11652
11653 if (!args) SWIG_fail;
11654 swig_obj[0] = args;
11655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11656 if (!SWIG_IsOK(res1)) {
11657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11658 }
11659 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (arg1)->FindNext();
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 #if wxUSE_UNICODE
11668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11669 #else
11670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11671 #endif
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 PyObject *obj;
11681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11682 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11683 return SWIG_Py_Void();
11684 }
11685
11686 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11687 return SWIG_Python_InitShadowInstance(args);
11688 }
11689
11690 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11691 PyObject *resultobj = 0;
11692 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11693 wxString result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 PyObject *swig_obj[1] ;
11697
11698 if (!args) SWIG_fail;
11699 swig_obj[0] = args;
11700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11703 }
11704 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (arg1)->GetName();
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 #if wxUSE_UNICODE
11713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11714 #else
11715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11716 #endif
11717 }
11718 return resultobj;
11719 fail:
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 PyObject *resultobj = 0;
11726 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11727 wxString result;
11728 void *argp1 = 0 ;
11729 int res1 = 0 ;
11730 PyObject *swig_obj[1] ;
11731
11732 if (!args) SWIG_fail;
11733 swig_obj[0] = args;
11734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11737 }
11738 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11739 {
11740 PyThreadState* __tstate = wxPyBeginAllowThreads();
11741 result = (arg1)->GetExtension();
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 #if wxUSE_UNICODE
11747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11748 #else
11749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11750 #endif
11751 }
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11759 PyObject *resultobj = 0;
11760 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11761 long result;
11762 void *argp1 = 0 ;
11763 int res1 = 0 ;
11764 PyObject *swig_obj[1] ;
11765
11766 if (!args) SWIG_fail;
11767 swig_obj[0] = args;
11768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11769 if (!SWIG_IsOK(res1)) {
11770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11771 }
11772 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (long)(arg1)->GetType();
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 resultobj = SWIG_From_long(static_cast< long >(result));
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *resultobj = 0;
11788 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11789 wxString result;
11790 void *argp1 = 0 ;
11791 int res1 = 0 ;
11792 PyObject *swig_obj[1] ;
11793
11794 if (!args) SWIG_fail;
11795 swig_obj[0] = args;
11796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11799 }
11800 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (arg1)->GetMimeType();
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 #if wxUSE_UNICODE
11809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11810 #else
11811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11812 #endif
11813 }
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11821 PyObject *resultobj = 0;
11822 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11823 wxString *arg2 = 0 ;
11824 bool result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 bool temp2 = false ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 char * kwnames[] = {
11831 (char *) "self",(char *) "name", NULL
11832 };
11833
11834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11836 if (!SWIG_IsOK(res1)) {
11837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11838 }
11839 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11840 {
11841 arg2 = wxString_in_helper(obj1);
11842 if (arg2 == NULL) SWIG_fail;
11843 temp2 = true;
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11853 }
11854 {
11855 if (temp2)
11856 delete arg2;
11857 }
11858 return resultobj;
11859 fail:
11860 {
11861 if (temp2)
11862 delete arg2;
11863 }
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11871 wxInputStream *arg2 = 0 ;
11872 bool result;
11873 void *argp1 = 0 ;
11874 int res1 = 0 ;
11875 wxPyInputStream *temp2 ;
11876 bool created2 ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 char * kwnames[] = {
11880 (char *) "self",(char *) "stream", NULL
11881 };
11882
11883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11887 }
11888 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11889 {
11890 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11891 arg2 = temp2->m_wxis;
11892 created2 = false;
11893 } else {
11894 PyErr_Clear(); // clear the failure of the wxPyConvert above
11895 arg2 = wxPyCBInputStream_create(obj1, false);
11896 if (arg2 == NULL) {
11897 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11898 SWIG_fail;
11899 }
11900 created2 = true;
11901 }
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (bool)(arg1)->CanRead(*arg2);
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 {
11910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11911 }
11912 {
11913 if (created2) delete arg2;
11914 }
11915 return resultobj;
11916 fail:
11917 {
11918 if (created2) delete arg2;
11919 }
11920 return NULL;
11921 }
11922
11923
11924 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11925 PyObject *resultobj = 0;
11926 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11927 wxString *arg2 = 0 ;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 bool temp2 = false ;
11931 PyObject * obj0 = 0 ;
11932 PyObject * obj1 = 0 ;
11933 char * kwnames[] = {
11934 (char *) "self",(char *) "name", NULL
11935 };
11936
11937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11939 if (!SWIG_IsOK(res1)) {
11940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11941 }
11942 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11943 {
11944 arg2 = wxString_in_helper(obj1);
11945 if (arg2 == NULL) SWIG_fail;
11946 temp2 = true;
11947 }
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 (arg1)->SetName((wxString const &)*arg2);
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 resultobj = SWIG_Py_Void();
11955 {
11956 if (temp2)
11957 delete arg2;
11958 }
11959 return resultobj;
11960 fail:
11961 {
11962 if (temp2)
11963 delete arg2;
11964 }
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj = 0;
11971 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11972 wxString *arg2 = 0 ;
11973 void *argp1 = 0 ;
11974 int res1 = 0 ;
11975 bool temp2 = false ;
11976 PyObject * obj0 = 0 ;
11977 PyObject * obj1 = 0 ;
11978 char * kwnames[] = {
11979 (char *) "self",(char *) "extension", NULL
11980 };
11981
11982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11984 if (!SWIG_IsOK(res1)) {
11985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11986 }
11987 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11988 {
11989 arg2 = wxString_in_helper(obj1);
11990 if (arg2 == NULL) SWIG_fail;
11991 temp2 = true;
11992 }
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 (arg1)->SetExtension((wxString const &)*arg2);
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 resultobj = SWIG_Py_Void();
12000 {
12001 if (temp2)
12002 delete arg2;
12003 }
12004 return resultobj;
12005 fail:
12006 {
12007 if (temp2)
12008 delete arg2;
12009 }
12010 return NULL;
12011 }
12012
12013
12014 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12015 PyObject *resultobj = 0;
12016 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12017 long arg2 ;
12018 void *argp1 = 0 ;
12019 int res1 = 0 ;
12020 long val2 ;
12021 int ecode2 = 0 ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 char * kwnames[] = {
12025 (char *) "self",(char *) "type", NULL
12026 };
12027
12028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12032 }
12033 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12034 ecode2 = SWIG_AsVal_long(obj1, &val2);
12035 if (!SWIG_IsOK(ecode2)) {
12036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12037 }
12038 arg2 = static_cast< long >(val2);
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 (arg1)->SetType(arg2);
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_Py_Void();
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj = 0;
12054 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12055 wxString *arg2 = 0 ;
12056 void *argp1 = 0 ;
12057 int res1 = 0 ;
12058 bool temp2 = false ;
12059 PyObject * obj0 = 0 ;
12060 PyObject * obj1 = 0 ;
12061 char * kwnames[] = {
12062 (char *) "self",(char *) "mimetype", NULL
12063 };
12064
12065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12069 }
12070 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12071 {
12072 arg2 = wxString_in_helper(obj1);
12073 if (arg2 == NULL) SWIG_fail;
12074 temp2 = true;
12075 }
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 (arg1)->SetMimeType((wxString const &)*arg2);
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 resultobj = SWIG_Py_Void();
12083 {
12084 if (temp2)
12085 delete arg2;
12086 }
12087 return resultobj;
12088 fail:
12089 {
12090 if (temp2)
12091 delete arg2;
12092 }
12093 return NULL;
12094 }
12095
12096
12097 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12098 PyObject *obj;
12099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12100 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12101 return SWIG_Py_Void();
12102 }
12103
12104 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12105 PyObject *resultobj = 0;
12106 wxPyImageHandler *result = 0 ;
12107
12108 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 result = (wxPyImageHandler *)new wxPyImageHandler();
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj = 0;
12124 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12125 PyObject *arg2 = (PyObject *) 0 ;
12126 void *argp1 = 0 ;
12127 int res1 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 char * kwnames[] = {
12131 (char *) "self",(char *) "self", NULL
12132 };
12133
12134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12136 if (!SWIG_IsOK(res1)) {
12137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12138 }
12139 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12140 arg2 = obj1;
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 (arg1)->_SetSelf(arg2);
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 resultobj = SWIG_Py_Void();
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12155 PyObject *obj;
12156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12157 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12158 return SWIG_Py_Void();
12159 }
12160
12161 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12162 return SWIG_Python_InitShadowInstance(args);
12163 }
12164
12165 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12166 PyObject *resultobj = 0;
12167 wxImageHistogram *result = 0 ;
12168
12169 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (wxImageHistogram *)new wxImageHistogram();
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj = 0;
12185 byte arg1 ;
12186 byte arg2 ;
12187 byte arg3 ;
12188 unsigned long result;
12189 unsigned char val1 ;
12190 int ecode1 = 0 ;
12191 unsigned char val2 ;
12192 int ecode2 = 0 ;
12193 unsigned char val3 ;
12194 int ecode3 = 0 ;
12195 PyObject * obj0 = 0 ;
12196 PyObject * obj1 = 0 ;
12197 PyObject * obj2 = 0 ;
12198 char * kwnames[] = {
12199 (char *) "r",(char *) "g",(char *) "b", NULL
12200 };
12201
12202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12203 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12204 if (!SWIG_IsOK(ecode1)) {
12205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12206 }
12207 arg1 = static_cast< byte >(val1);
12208 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12209 if (!SWIG_IsOK(ecode2)) {
12210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12211 }
12212 arg2 = static_cast< byte >(val2);
12213 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12214 if (!SWIG_IsOK(ecode3)) {
12215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12216 }
12217 arg3 = static_cast< byte >(val3);
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12234 byte *arg2 = (byte *) 0 ;
12235 byte *arg3 = (byte *) 0 ;
12236 byte *arg4 = (byte *) 0 ;
12237 byte arg5 = (byte) 1 ;
12238 byte arg6 = (byte) 0 ;
12239 byte arg7 = (byte) 0 ;
12240 bool result;
12241 void *argp1 = 0 ;
12242 int res1 = 0 ;
12243 byte temp2 ;
12244 int res2 = SWIG_TMPOBJ ;
12245 byte temp3 ;
12246 int res3 = SWIG_TMPOBJ ;
12247 byte temp4 ;
12248 int res4 = SWIG_TMPOBJ ;
12249 unsigned char val5 ;
12250 int ecode5 = 0 ;
12251 unsigned char val6 ;
12252 int ecode6 = 0 ;
12253 unsigned char val7 ;
12254 int ecode7 = 0 ;
12255 PyObject * obj0 = 0 ;
12256 PyObject * obj1 = 0 ;
12257 PyObject * obj2 = 0 ;
12258 PyObject * obj3 = 0 ;
12259 char * kwnames[] = {
12260 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12261 };
12262
12263 arg2 = &temp2;
12264 arg3 = &temp3;
12265 arg4 = &temp4;
12266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12268 if (!SWIG_IsOK(res1)) {
12269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12270 }
12271 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12272 if (obj1) {
12273 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12274 if (!SWIG_IsOK(ecode5)) {
12275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12276 }
12277 arg5 = static_cast< byte >(val5);
12278 }
12279 if (obj2) {
12280 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12281 if (!SWIG_IsOK(ecode6)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12283 }
12284 arg6 = static_cast< byte >(val6);
12285 }
12286 if (obj3) {
12287 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12288 if (!SWIG_IsOK(ecode7)) {
12289 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12290 }
12291 arg7 = static_cast< byte >(val7);
12292 }
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 {
12300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12301 }
12302 if (SWIG_IsTmpObj(res2)) {
12303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12304 } else {
12305 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12307 }
12308 if (SWIG_IsTmpObj(res3)) {
12309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12310 } else {
12311 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12313 }
12314 if (SWIG_IsTmpObj(res4)) {
12315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12316 } else {
12317 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj = 0;
12328 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12329 unsigned long arg2 ;
12330 unsigned long result;
12331 void *argp1 = 0 ;
12332 int res1 = 0 ;
12333 unsigned long val2 ;
12334 int ecode2 = 0 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 char * kwnames[] = {
12338 (char *) "self",(char *) "key", NULL
12339 };
12340
12341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12343 if (!SWIG_IsOK(res1)) {
12344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12345 }
12346 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12347 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12348 if (!SWIG_IsOK(ecode2)) {
12349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12350 }
12351 arg2 = static_cast< unsigned long >(val2);
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj = 0;
12367 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12368 byte arg2 ;
12369 byte arg3 ;
12370 byte arg4 ;
12371 unsigned long result;
12372 void *argp1 = 0 ;
12373 int res1 = 0 ;
12374 unsigned char val2 ;
12375 int ecode2 = 0 ;
12376 unsigned char val3 ;
12377 int ecode3 = 0 ;
12378 unsigned char val4 ;
12379 int ecode4 = 0 ;
12380 PyObject * obj0 = 0 ;
12381 PyObject * obj1 = 0 ;
12382 PyObject * obj2 = 0 ;
12383 PyObject * obj3 = 0 ;
12384 char * kwnames[] = {
12385 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12386 };
12387
12388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12390 if (!SWIG_IsOK(res1)) {
12391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12392 }
12393 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12394 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12395 if (!SWIG_IsOK(ecode2)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12397 }
12398 arg2 = static_cast< byte >(val2);
12399 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12400 if (!SWIG_IsOK(ecode3)) {
12401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12402 }
12403 arg3 = static_cast< byte >(val3);
12404 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12405 if (!SWIG_IsOK(ecode4)) {
12406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12407 }
12408 arg4 = static_cast< byte >(val4);
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj = 0;
12424 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12425 wxColour *arg2 = 0 ;
12426 unsigned long result;
12427 void *argp1 = 0 ;
12428 int res1 = 0 ;
12429 wxColour temp2 ;
12430 PyObject * obj0 = 0 ;
12431 PyObject * obj1 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "self",(char *) "colour", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12440 }
12441 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12442 {
12443 arg2 = &temp2;
12444 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12460 PyObject *obj;
12461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12462 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12463 return SWIG_Py_Void();
12464 }
12465
12466 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12467 return SWIG_Python_InitShadowInstance(args);
12468 }
12469
12470 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj = 0;
12472 byte arg1 = (byte) 0 ;
12473 byte arg2 = (byte) 0 ;
12474 byte arg3 = (byte) 0 ;
12475 wxImage_RGBValue *result = 0 ;
12476 unsigned char val1 ;
12477 int ecode1 = 0 ;
12478 unsigned char val2 ;
12479 int ecode2 = 0 ;
12480 unsigned char val3 ;
12481 int ecode3 = 0 ;
12482 PyObject * obj0 = 0 ;
12483 PyObject * obj1 = 0 ;
12484 PyObject * obj2 = 0 ;
12485 char * kwnames[] = {
12486 (char *) "r",(char *) "g",(char *) "b", NULL
12487 };
12488
12489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12490 if (obj0) {
12491 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12492 if (!SWIG_IsOK(ecode1)) {
12493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12494 }
12495 arg1 = static_cast< byte >(val1);
12496 }
12497 if (obj1) {
12498 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12499 if (!SWIG_IsOK(ecode2)) {
12500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12501 }
12502 arg2 = static_cast< byte >(val2);
12503 }
12504 if (obj2) {
12505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12506 if (!SWIG_IsOK(ecode3)) {
12507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12508 }
12509 arg3 = static_cast< byte >(val3);
12510 }
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12525 PyObject *resultobj = 0;
12526 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12527 byte arg2 ;
12528 void *argp1 = 0 ;
12529 int res1 = 0 ;
12530 unsigned char val2 ;
12531 int ecode2 = 0 ;
12532 PyObject *swig_obj[2] ;
12533
12534 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12538 }
12539 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12540 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12541 if (!SWIG_IsOK(ecode2)) {
12542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12543 }
12544 arg2 = static_cast< byte >(val2);
12545 if (arg1) (arg1)->red = arg2;
12546
12547 resultobj = SWIG_Py_Void();
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *resultobj = 0;
12556 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12557 byte result;
12558 void *argp1 = 0 ;
12559 int res1 = 0 ;
12560 PyObject *swig_obj[1] ;
12561
12562 if (!args) SWIG_fail;
12563 swig_obj[0] = args;
12564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12565 if (!SWIG_IsOK(res1)) {
12566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12567 }
12568 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12569 result = (byte) ((arg1)->red);
12570 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12571 return resultobj;
12572 fail:
12573 return NULL;
12574 }
12575
12576
12577 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12578 PyObject *resultobj = 0;
12579 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12580 byte arg2 ;
12581 void *argp1 = 0 ;
12582 int res1 = 0 ;
12583 unsigned char val2 ;
12584 int ecode2 = 0 ;
12585 PyObject *swig_obj[2] ;
12586
12587 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12589 if (!SWIG_IsOK(res1)) {
12590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12591 }
12592 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12593 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12594 if (!SWIG_IsOK(ecode2)) {
12595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12596 }
12597 arg2 = static_cast< byte >(val2);
12598 if (arg1) (arg1)->green = arg2;
12599
12600 resultobj = SWIG_Py_Void();
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12608 PyObject *resultobj = 0;
12609 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12610 byte result;
12611 void *argp1 = 0 ;
12612 int res1 = 0 ;
12613 PyObject *swig_obj[1] ;
12614
12615 if (!args) SWIG_fail;
12616 swig_obj[0] = args;
12617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12618 if (!SWIG_IsOK(res1)) {
12619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12620 }
12621 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12622 result = (byte) ((arg1)->green);
12623 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 PyObject *resultobj = 0;
12632 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12633 byte arg2 ;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 unsigned char val2 ;
12637 int ecode2 = 0 ;
12638 PyObject *swig_obj[2] ;
12639
12640 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12642 if (!SWIG_IsOK(res1)) {
12643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12644 }
12645 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12646 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12647 if (!SWIG_IsOK(ecode2)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12649 }
12650 arg2 = static_cast< byte >(val2);
12651 if (arg1) (arg1)->blue = arg2;
12652
12653 resultobj = SWIG_Py_Void();
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12661 PyObject *resultobj = 0;
12662 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12663 byte result;
12664 void *argp1 = 0 ;
12665 int res1 = 0 ;
12666 PyObject *swig_obj[1] ;
12667
12668 if (!args) SWIG_fail;
12669 swig_obj[0] = args;
12670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12671 if (!SWIG_IsOK(res1)) {
12672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12673 }
12674 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12675 result = (byte) ((arg1)->blue);
12676 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *obj;
12685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12686 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12687 return SWIG_Py_Void();
12688 }
12689
12690 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12691 return SWIG_Python_InitShadowInstance(args);
12692 }
12693
12694 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12695 PyObject *resultobj = 0;
12696 double arg1 = (double) 0.0 ;
12697 double arg2 = (double) 0.0 ;
12698 double arg3 = (double) 0.0 ;
12699 wxImage_HSVValue *result = 0 ;
12700 double val1 ;
12701 int ecode1 = 0 ;
12702 double val2 ;
12703 int ecode2 = 0 ;
12704 double val3 ;
12705 int ecode3 = 0 ;
12706 PyObject * obj0 = 0 ;
12707 PyObject * obj1 = 0 ;
12708 PyObject * obj2 = 0 ;
12709 char * kwnames[] = {
12710 (char *) "h",(char *) "s",(char *) "v", NULL
12711 };
12712
12713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12714 if (obj0) {
12715 ecode1 = SWIG_AsVal_double(obj0, &val1);
12716 if (!SWIG_IsOK(ecode1)) {
12717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12718 }
12719 arg1 = static_cast< double >(val1);
12720 }
12721 if (obj1) {
12722 ecode2 = SWIG_AsVal_double(obj1, &val2);
12723 if (!SWIG_IsOK(ecode2)) {
12724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12725 }
12726 arg2 = static_cast< double >(val2);
12727 }
12728 if (obj2) {
12729 ecode3 = SWIG_AsVal_double(obj2, &val3);
12730 if (!SWIG_IsOK(ecode3)) {
12731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12732 }
12733 arg3 = static_cast< double >(val3);
12734 }
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12742 return resultobj;
12743 fail:
12744 return NULL;
12745 }
12746
12747
12748 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12749 PyObject *resultobj = 0;
12750 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12751 double arg2 ;
12752 void *argp1 = 0 ;
12753 int res1 = 0 ;
12754 double val2 ;
12755 int ecode2 = 0 ;
12756 PyObject *swig_obj[2] ;
12757
12758 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12762 }
12763 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12764 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12765 if (!SWIG_IsOK(ecode2)) {
12766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12767 }
12768 arg2 = static_cast< double >(val2);
12769 if (arg1) (arg1)->hue = arg2;
12770
12771 resultobj = SWIG_Py_Void();
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *resultobj = 0;
12780 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12781 double result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 PyObject *swig_obj[1] ;
12785
12786 if (!args) SWIG_fail;
12787 swig_obj[0] = args;
12788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12789 if (!SWIG_IsOK(res1)) {
12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12791 }
12792 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12793 result = (double) ((arg1)->hue);
12794 resultobj = SWIG_From_double(static_cast< double >(result));
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12804 double arg2 ;
12805 void *argp1 = 0 ;
12806 int res1 = 0 ;
12807 double val2 ;
12808 int ecode2 = 0 ;
12809 PyObject *swig_obj[2] ;
12810
12811 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12815 }
12816 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12817 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12818 if (!SWIG_IsOK(ecode2)) {
12819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12820 }
12821 arg2 = static_cast< double >(val2);
12822 if (arg1) (arg1)->saturation = arg2;
12823
12824 resultobj = SWIG_Py_Void();
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832 PyObject *resultobj = 0;
12833 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12834 double result;
12835 void *argp1 = 0 ;
12836 int res1 = 0 ;
12837 PyObject *swig_obj[1] ;
12838
12839 if (!args) SWIG_fail;
12840 swig_obj[0] = args;
12841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12842 if (!SWIG_IsOK(res1)) {
12843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12844 }
12845 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12846 result = (double) ((arg1)->saturation);
12847 resultobj = SWIG_From_double(static_cast< double >(result));
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12857 double arg2 ;
12858 void *argp1 = 0 ;
12859 int res1 = 0 ;
12860 double val2 ;
12861 int ecode2 = 0 ;
12862 PyObject *swig_obj[2] ;
12863
12864 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12866 if (!SWIG_IsOK(res1)) {
12867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12868 }
12869 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12870 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12873 }
12874 arg2 = static_cast< double >(val2);
12875 if (arg1) (arg1)->value = arg2;
12876
12877 resultobj = SWIG_Py_Void();
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12885 PyObject *resultobj = 0;
12886 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12887 double result;
12888 void *argp1 = 0 ;
12889 int res1 = 0 ;
12890 PyObject *swig_obj[1] ;
12891
12892 if (!args) SWIG_fail;
12893 swig_obj[0] = args;
12894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12895 if (!SWIG_IsOK(res1)) {
12896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12897 }
12898 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12899 result = (double) ((arg1)->value);
12900 resultobj = SWIG_From_double(static_cast< double >(result));
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *obj;
12909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12910 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12911 return SWIG_Py_Void();
12912 }
12913
12914 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12915 return SWIG_Python_InitShadowInstance(args);
12916 }
12917
12918 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj = 0;
12920 wxString *arg1 = 0 ;
12921 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12922 int arg3 = (int) -1 ;
12923 wxImage *result = 0 ;
12924 bool temp1 = false ;
12925 long val2 ;
12926 int ecode2 = 0 ;
12927 int val3 ;
12928 int ecode3 = 0 ;
12929 PyObject * obj0 = 0 ;
12930 PyObject * obj1 = 0 ;
12931 PyObject * obj2 = 0 ;
12932 char * kwnames[] = {
12933 (char *) "name",(char *) "type",(char *) "index", NULL
12934 };
12935
12936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12937 {
12938 arg1 = wxString_in_helper(obj0);
12939 if (arg1 == NULL) SWIG_fail;
12940 temp1 = true;
12941 }
12942 if (obj1) {
12943 ecode2 = SWIG_AsVal_long(obj1, &val2);
12944 if (!SWIG_IsOK(ecode2)) {
12945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12946 }
12947 arg2 = static_cast< long >(val2);
12948 }
12949 if (obj2) {
12950 ecode3 = SWIG_AsVal_int(obj2, &val3);
12951 if (!SWIG_IsOK(ecode3)) {
12952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12953 }
12954 arg3 = static_cast< int >(val3);
12955 }
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12959 wxPyEndAllowThreads(__tstate);
12960 if (PyErr_Occurred()) SWIG_fail;
12961 }
12962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12963 {
12964 if (temp1)
12965 delete arg1;
12966 }
12967 return resultobj;
12968 fail:
12969 {
12970 if (temp1)
12971 delete arg1;
12972 }
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 PyObject *resultobj = 0;
12979 wxImage *arg1 = (wxImage *) 0 ;
12980 void *argp1 = 0 ;
12981 int res1 = 0 ;
12982 PyObject *swig_obj[1] ;
12983
12984 if (!args) SWIG_fail;
12985 swig_obj[0] = args;
12986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12989 }
12990 arg1 = reinterpret_cast< wxImage * >(argp1);
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 delete arg1;
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 resultobj = SWIG_Py_Void();
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj = 0;
13007 wxString *arg1 = 0 ;
13008 wxString *arg2 = 0 ;
13009 int arg3 = (int) -1 ;
13010 wxImage *result = 0 ;
13011 bool temp1 = false ;
13012 bool temp2 = false ;
13013 int val3 ;
13014 int ecode3 = 0 ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 PyObject * obj2 = 0 ;
13018 char * kwnames[] = {
13019 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13020 };
13021
13022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13023 {
13024 arg1 = wxString_in_helper(obj0);
13025 if (arg1 == NULL) SWIG_fail;
13026 temp1 = true;
13027 }
13028 {
13029 arg2 = wxString_in_helper(obj1);
13030 if (arg2 == NULL) SWIG_fail;
13031 temp2 = true;
13032 }
13033 if (obj2) {
13034 ecode3 = SWIG_AsVal_int(obj2, &val3);
13035 if (!SWIG_IsOK(ecode3)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13037 }
13038 arg3 = static_cast< int >(val3);
13039 }
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13047 {
13048 if (temp1)
13049 delete arg1;
13050 }
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return resultobj;
13056 fail:
13057 {
13058 if (temp1)
13059 delete arg1;
13060 }
13061 {
13062 if (temp2)
13063 delete arg2;
13064 }
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj = 0;
13071 wxInputStream *arg1 = 0 ;
13072 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13073 int arg3 = (int) -1 ;
13074 wxImage *result = 0 ;
13075 wxPyInputStream *temp1 ;
13076 bool created1 ;
13077 long val2 ;
13078 int ecode2 = 0 ;
13079 int val3 ;
13080 int ecode3 = 0 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 PyObject * obj2 = 0 ;
13084 char * kwnames[] = {
13085 (char *) "stream",(char *) "type",(char *) "index", NULL
13086 };
13087
13088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13089 {
13090 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13091 arg1 = temp1->m_wxis;
13092 created1 = false;
13093 } else {
13094 PyErr_Clear(); // clear the failure of the wxPyConvert above
13095 arg1 = wxPyCBInputStream_create(obj0, false);
13096 if (arg1 == NULL) {
13097 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13098 SWIG_fail;
13099 }
13100 created1 = true;
13101 }
13102 }
13103 if (obj1) {
13104 ecode2 = SWIG_AsVal_long(obj1, &val2);
13105 if (!SWIG_IsOK(ecode2)) {
13106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13107 }
13108 arg2 = static_cast< long >(val2);
13109 }
13110 if (obj2) {
13111 ecode3 = SWIG_AsVal_int(obj2, &val3);
13112 if (!SWIG_IsOK(ecode3)) {
13113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13114 }
13115 arg3 = static_cast< int >(val3);
13116 }
13117 {
13118 PyThreadState* __tstate = wxPyBeginAllowThreads();
13119 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13120 wxPyEndAllowThreads(__tstate);
13121 if (PyErr_Occurred()) SWIG_fail;
13122 }
13123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13124 {
13125 if (created1) delete arg1;
13126 }
13127 return resultobj;
13128 fail:
13129 {
13130 if (created1) delete arg1;
13131 }
13132 return NULL;
13133 }
13134
13135
13136 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj = 0;
13138 wxInputStream *arg1 = 0 ;
13139 wxString *arg2 = 0 ;
13140 int arg3 = (int) -1 ;
13141 wxImage *result = 0 ;
13142 wxPyInputStream *temp1 ;
13143 bool created1 ;
13144 bool temp2 = false ;
13145 int val3 ;
13146 int ecode3 = 0 ;
13147 PyObject * obj0 = 0 ;
13148 PyObject * obj1 = 0 ;
13149 PyObject * obj2 = 0 ;
13150 char * kwnames[] = {
13151 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13152 };
13153
13154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13155 {
13156 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13157 arg1 = temp1->m_wxis;
13158 created1 = false;
13159 } else {
13160 PyErr_Clear(); // clear the failure of the wxPyConvert above
13161 arg1 = wxPyCBInputStream_create(obj0, false);
13162 if (arg1 == NULL) {
13163 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13164 SWIG_fail;
13165 }
13166 created1 = true;
13167 }
13168 }
13169 {
13170 arg2 = wxString_in_helper(obj1);
13171 if (arg2 == NULL) SWIG_fail;
13172 temp2 = true;
13173 }
13174 if (obj2) {
13175 ecode3 = SWIG_AsVal_int(obj2, &val3);
13176 if (!SWIG_IsOK(ecode3)) {
13177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13178 }
13179 arg3 = static_cast< int >(val3);
13180 }
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13184 wxPyEndAllowThreads(__tstate);
13185 if (PyErr_Occurred()) SWIG_fail;
13186 }
13187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13188 {
13189 if (created1) delete arg1;
13190 }
13191 {
13192 if (temp2)
13193 delete arg2;
13194 }
13195 return resultobj;
13196 fail:
13197 {
13198 if (created1) delete arg1;
13199 }
13200 {
13201 if (temp2)
13202 delete arg2;
13203 }
13204 return NULL;
13205 }
13206
13207
13208 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj = 0;
13210 int arg1 = (int) 0 ;
13211 int arg2 = (int) 0 ;
13212 bool arg3 = (bool) true ;
13213 wxImage *result = 0 ;
13214 int val1 ;
13215 int ecode1 = 0 ;
13216 int val2 ;
13217 int ecode2 = 0 ;
13218 bool val3 ;
13219 int ecode3 = 0 ;
13220 PyObject * obj0 = 0 ;
13221 PyObject * obj1 = 0 ;
13222 PyObject * obj2 = 0 ;
13223 char * kwnames[] = {
13224 (char *) "width",(char *) "height",(char *) "clear", NULL
13225 };
13226
13227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13228 if (obj0) {
13229 ecode1 = SWIG_AsVal_int(obj0, &val1);
13230 if (!SWIG_IsOK(ecode1)) {
13231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13232 }
13233 arg1 = static_cast< int >(val1);
13234 }
13235 if (obj1) {
13236 ecode2 = SWIG_AsVal_int(obj1, &val2);
13237 if (!SWIG_IsOK(ecode2)) {
13238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13239 }
13240 arg2 = static_cast< int >(val2);
13241 }
13242 if (obj2) {
13243 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13244 if (!SWIG_IsOK(ecode3)) {
13245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13246 }
13247 arg3 = static_cast< bool >(val3);
13248 }
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj = 0;
13264 wxBitmap *arg1 = 0 ;
13265 wxImage *result = 0 ;
13266 void *argp1 = 0 ;
13267 int res1 = 0 ;
13268 PyObject * obj0 = 0 ;
13269 char * kwnames[] = {
13270 (char *) "bitmap", NULL
13271 };
13272
13273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13274 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13275 if (!SWIG_IsOK(res1)) {
13276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13277 }
13278 if (!argp1) {
13279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13280 }
13281 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13282 {
13283 if (!wxPyCheckForApp()) SWIG_fail;
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13286 wxPyEndAllowThreads(__tstate);
13287 if (PyErr_Occurred()) SWIG_fail;
13288 }
13289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj = 0;
13298 int arg1 ;
13299 int arg2 ;
13300 buffer arg3 ;
13301 int arg4 ;
13302 wxImage *result = 0 ;
13303 int val1 ;
13304 int ecode1 = 0 ;
13305 int val2 ;
13306 int ecode2 = 0 ;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 PyObject * obj2 = 0 ;
13310 char * kwnames[] = {
13311 (char *) "width",(char *) "height",(char *) "data", NULL
13312 };
13313
13314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13315 ecode1 = SWIG_AsVal_int(obj0, &val1);
13316 if (!SWIG_IsOK(ecode1)) {
13317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13318 }
13319 arg1 = static_cast< int >(val1);
13320 ecode2 = SWIG_AsVal_int(obj1, &val2);
13321 if (!SWIG_IsOK(ecode2)) {
13322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13323 }
13324 arg2 = static_cast< int >(val2);
13325 {
13326 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13327 }
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13331 wxPyEndAllowThreads(__tstate);
13332 if (PyErr_Occurred()) SWIG_fail;
13333 }
13334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13342 PyObject *resultobj = 0;
13343 int arg1 ;
13344 int arg2 ;
13345 buffer arg3 ;
13346 int arg4 ;
13347 buffer arg5 ;
13348 int arg6 ;
13349 wxImage *result = 0 ;
13350 int val1 ;
13351 int ecode1 = 0 ;
13352 int val2 ;
13353 int ecode2 = 0 ;
13354 PyObject * obj0 = 0 ;
13355 PyObject * obj1 = 0 ;
13356 PyObject * obj2 = 0 ;
13357 PyObject * obj3 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13363 ecode1 = SWIG_AsVal_int(obj0, &val1);
13364 if (!SWIG_IsOK(ecode1)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13366 }
13367 arg1 = static_cast< int >(val1);
13368 ecode2 = SWIG_AsVal_int(obj1, &val2);
13369 if (!SWIG_IsOK(ecode2)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13371 }
13372 arg2 = static_cast< int >(val2);
13373 {
13374 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13375 }
13376 {
13377 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13386 return resultobj;
13387 fail:
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13393 PyObject *resultobj = 0;
13394 wxImage *arg1 = (wxImage *) 0 ;
13395 int arg2 ;
13396 int arg3 ;
13397 bool arg4 = (bool) true ;
13398 void *argp1 = 0 ;
13399 int res1 = 0 ;
13400 int val2 ;
13401 int ecode2 = 0 ;
13402 int val3 ;
13403 int ecode3 = 0 ;
13404 bool val4 ;
13405 int ecode4 = 0 ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 PyObject * obj2 = 0 ;
13409 PyObject * obj3 = 0 ;
13410 char * kwnames[] = {
13411 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13412 };
13413
13414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13416 if (!SWIG_IsOK(res1)) {
13417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13418 }
13419 arg1 = reinterpret_cast< wxImage * >(argp1);
13420 ecode2 = SWIG_AsVal_int(obj1, &val2);
13421 if (!SWIG_IsOK(ecode2)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13423 }
13424 arg2 = static_cast< int >(val2);
13425 ecode3 = SWIG_AsVal_int(obj2, &val3);
13426 if (!SWIG_IsOK(ecode3)) {
13427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13428 }
13429 arg3 = static_cast< int >(val3);
13430 if (obj3) {
13431 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13432 if (!SWIG_IsOK(ecode4)) {
13433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13434 }
13435 arg4 = static_cast< bool >(val4);
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 (arg1)->Create(arg2,arg3,arg4);
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_Py_Void();
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13451 PyObject *resultobj = 0;
13452 wxImage *arg1 = (wxImage *) 0 ;
13453 void *argp1 = 0 ;
13454 int res1 = 0 ;
13455 PyObject *swig_obj[1] ;
13456
13457 if (!args) SWIG_fail;
13458 swig_obj[0] = args;
13459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13460 if (!SWIG_IsOK(res1)) {
13461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13462 }
13463 arg1 = reinterpret_cast< wxImage * >(argp1);
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 (arg1)->Destroy();
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 resultobj = SWIG_Py_Void();
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj = 0;
13479 wxImage *arg1 = (wxImage *) 0 ;
13480 int arg2 ;
13481 int arg3 ;
13482 SwigValueWrapper<wxImage > result;
13483 void *argp1 = 0 ;
13484 int res1 = 0 ;
13485 int val2 ;
13486 int ecode2 = 0 ;
13487 int val3 ;
13488 int ecode3 = 0 ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 PyObject * obj2 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "width",(char *) "height", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13500 }
13501 arg1 = reinterpret_cast< wxImage * >(argp1);
13502 ecode2 = SWIG_AsVal_int(obj1, &val2);
13503 if (!SWIG_IsOK(ecode2)) {
13504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13505 }
13506 arg2 = static_cast< int >(val2);
13507 ecode3 = SWIG_AsVal_int(obj2, &val3);
13508 if (!SWIG_IsOK(ecode3)) {
13509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13510 }
13511 arg3 = static_cast< int >(val3);
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 result = (arg1)->Scale(arg2,arg3);
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj = 0;
13527 wxImage *arg1 = (wxImage *) 0 ;
13528 int arg2 ;
13529 int arg3 ;
13530 SwigValueWrapper<wxImage > result;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 int val2 ;
13534 int ecode2 = 0 ;
13535 int val3 ;
13536 int ecode3 = 0 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13546 if (!SWIG_IsOK(res1)) {
13547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13548 }
13549 arg1 = reinterpret_cast< wxImage * >(argp1);
13550 ecode2 = SWIG_AsVal_int(obj1, &val2);
13551 if (!SWIG_IsOK(ecode2)) {
13552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13553 }
13554 arg2 = static_cast< int >(val2);
13555 ecode3 = SWIG_AsVal_int(obj2, &val3);
13556 if (!SWIG_IsOK(ecode3)) {
13557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13558 }
13559 arg3 = static_cast< int >(val3);
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 int arg2 ;
13577 int arg3 ;
13578 wxImage *result = 0 ;
13579 void *argp1 = 0 ;
13580 int res1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 int val3 ;
13584 int ecode3 = 0 ;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 PyObject * obj2 = 0 ;
13588 char * kwnames[] = {
13589 (char *) "self",(char *) "width",(char *) "height", NULL
13590 };
13591
13592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13594 if (!SWIG_IsOK(res1)) {
13595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13596 }
13597 arg1 = reinterpret_cast< wxImage * >(argp1);
13598 ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 if (!SWIG_IsOK(ecode2)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13601 }
13602 arg2 = static_cast< int >(val2);
13603 ecode3 = SWIG_AsVal_int(obj2, &val3);
13604 if (!SWIG_IsOK(ecode3)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13606 }
13607 arg3 = static_cast< int >(val3);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 {
13611 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13612 result = (wxImage *) &_result_ref;
13613 }
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxImage *arg1 = (wxImage *) 0 ;
13627 wxSize *arg2 = 0 ;
13628 wxPoint *arg3 = 0 ;
13629 int arg4 = (int) -1 ;
13630 int arg5 = (int) -1 ;
13631 int arg6 = (int) -1 ;
13632 wxImage *result = 0 ;
13633 void *argp1 = 0 ;
13634 int res1 = 0 ;
13635 wxSize temp2 ;
13636 wxPoint temp3 ;
13637 int val4 ;
13638 int ecode4 = 0 ;
13639 int val5 ;
13640 int ecode5 = 0 ;
13641 int val6 ;
13642 int ecode6 = 0 ;
13643 PyObject * obj0 = 0 ;
13644 PyObject * obj1 = 0 ;
13645 PyObject * obj2 = 0 ;
13646 PyObject * obj3 = 0 ;
13647 PyObject * obj4 = 0 ;
13648 PyObject * obj5 = 0 ;
13649 char * kwnames[] = {
13650 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13651 };
13652
13653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13655 if (!SWIG_IsOK(res1)) {
13656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13657 }
13658 arg1 = reinterpret_cast< wxImage * >(argp1);
13659 {
13660 arg2 = &temp2;
13661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13662 }
13663 {
13664 arg3 = &temp3;
13665 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13666 }
13667 if (obj3) {
13668 ecode4 = SWIG_AsVal_int(obj3, &val4);
13669 if (!SWIG_IsOK(ecode4)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13671 }
13672 arg4 = static_cast< int >(val4);
13673 }
13674 if (obj4) {
13675 ecode5 = SWIG_AsVal_int(obj4, &val5);
13676 if (!SWIG_IsOK(ecode5)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13678 }
13679 arg5 = static_cast< int >(val5);
13680 }
13681 if (obj5) {
13682 ecode6 = SWIG_AsVal_int(obj5, &val6);
13683 if (!SWIG_IsOK(ecode6)) {
13684 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13685 }
13686 arg6 = static_cast< int >(val6);
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 {
13691 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13692 result = (wxImage *) &_result_ref;
13693 }
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj = 0;
13706 wxImage *arg1 = (wxImage *) 0 ;
13707 int arg2 ;
13708 int arg3 ;
13709 byte arg4 ;
13710 byte arg5 ;
13711 byte arg6 ;
13712 void *argp1 = 0 ;
13713 int res1 = 0 ;
13714 int val2 ;
13715 int ecode2 = 0 ;
13716 int val3 ;
13717 int ecode3 = 0 ;
13718 unsigned char val4 ;
13719 int ecode4 = 0 ;
13720 unsigned char val5 ;
13721 int ecode5 = 0 ;
13722 unsigned char val6 ;
13723 int ecode6 = 0 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 PyObject * obj3 = 0 ;
13728 PyObject * obj4 = 0 ;
13729 PyObject * obj5 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13736 if (!SWIG_IsOK(res1)) {
13737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13738 }
13739 arg1 = reinterpret_cast< wxImage * >(argp1);
13740 ecode2 = SWIG_AsVal_int(obj1, &val2);
13741 if (!SWIG_IsOK(ecode2)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13743 }
13744 arg2 = static_cast< int >(val2);
13745 ecode3 = SWIG_AsVal_int(obj2, &val3);
13746 if (!SWIG_IsOK(ecode3)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13748 }
13749 arg3 = static_cast< int >(val3);
13750 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13751 if (!SWIG_IsOK(ecode4)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13753 }
13754 arg4 = static_cast< byte >(val4);
13755 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13756 if (!SWIG_IsOK(ecode5)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13758 }
13759 arg5 = static_cast< byte >(val5);
13760 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13761 if (!SWIG_IsOK(ecode6)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13763 }
13764 arg6 = static_cast< byte >(val6);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_Py_Void();
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 wxImage *arg1 = (wxImage *) 0 ;
13781 wxRect *arg2 = 0 ;
13782 byte arg3 ;
13783 byte arg4 ;
13784 byte arg5 ;
13785 void *argp1 = 0 ;
13786 int res1 = 0 ;
13787 wxRect temp2 ;
13788 unsigned char val3 ;
13789 int ecode3 = 0 ;
13790 unsigned char val4 ;
13791 int ecode4 = 0 ;
13792 unsigned char val5 ;
13793 int ecode5 = 0 ;
13794 PyObject * obj0 = 0 ;
13795 PyObject * obj1 = 0 ;
13796 PyObject * obj2 = 0 ;
13797 PyObject * obj3 = 0 ;
13798 PyObject * obj4 = 0 ;
13799 char * kwnames[] = {
13800 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13801 };
13802
13803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13805 if (!SWIG_IsOK(res1)) {
13806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13807 }
13808 arg1 = reinterpret_cast< wxImage * >(argp1);
13809 {
13810 arg2 = &temp2;
13811 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13812 }
13813 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13814 if (!SWIG_IsOK(ecode3)) {
13815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13816 }
13817 arg3 = static_cast< byte >(val3);
13818 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13819 if (!SWIG_IsOK(ecode4)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13821 }
13822 arg4 = static_cast< byte >(val4);
13823 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13824 if (!SWIG_IsOK(ecode5)) {
13825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13826 }
13827 arg5 = static_cast< byte >(val5);
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 resultobj = SWIG_Py_Void();
13835 return resultobj;
13836 fail:
13837 return NULL;
13838 }
13839
13840
13841 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj = 0;
13843 wxImage *arg1 = (wxImage *) 0 ;
13844 int arg2 ;
13845 int arg3 ;
13846 byte result;
13847 void *argp1 = 0 ;
13848 int res1 = 0 ;
13849 int val2 ;
13850 int ecode2 = 0 ;
13851 int val3 ;
13852 int ecode3 = 0 ;
13853 PyObject * obj0 = 0 ;
13854 PyObject * obj1 = 0 ;
13855 PyObject * obj2 = 0 ;
13856 char * kwnames[] = {
13857 (char *) "self",(char *) "x",(char *) "y", NULL
13858 };
13859
13860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13862 if (!SWIG_IsOK(res1)) {
13863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13864 }
13865 arg1 = reinterpret_cast< wxImage * >(argp1);
13866 ecode2 = SWIG_AsVal_int(obj1, &val2);
13867 if (!SWIG_IsOK(ecode2)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13869 }
13870 arg2 = static_cast< int >(val2);
13871 ecode3 = SWIG_AsVal_int(obj2, &val3);
13872 if (!SWIG_IsOK(ecode3)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13874 }
13875 arg3 = static_cast< int >(val3);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (byte)(arg1)->GetRed(arg2,arg3);
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 wxImage *arg1 = (wxImage *) 0 ;
13892 int arg2 ;
13893 int arg3 ;
13894 byte result;
13895 void *argp1 = 0 ;
13896 int res1 = 0 ;
13897 int val2 ;
13898 int ecode2 = 0 ;
13899 int val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "x",(char *) "y", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (byte)(arg1)->GetGreen(arg2,arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj = 0;
13939 wxImage *arg1 = (wxImage *) 0 ;
13940 int arg2 ;
13941 int arg3 ;
13942 byte result;
13943 void *argp1 = 0 ;
13944 int res1 = 0 ;
13945 int val2 ;
13946 int ecode2 = 0 ;
13947 int val3 ;
13948 int ecode3 = 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 PyObject * obj2 = 0 ;
13952 char * kwnames[] = {
13953 (char *) "self",(char *) "x",(char *) "y", NULL
13954 };
13955
13956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13958 if (!SWIG_IsOK(res1)) {
13959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13960 }
13961 arg1 = reinterpret_cast< wxImage * >(argp1);
13962 ecode2 = SWIG_AsVal_int(obj1, &val2);
13963 if (!SWIG_IsOK(ecode2)) {
13964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13965 }
13966 arg2 = static_cast< int >(val2);
13967 ecode3 = SWIG_AsVal_int(obj2, &val3);
13968 if (!SWIG_IsOK(ecode3)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13970 }
13971 arg3 = static_cast< int >(val3);
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 result = (byte)(arg1)->GetBlue(arg2,arg3);
13975 wxPyEndAllowThreads(__tstate);
13976 if (PyErr_Occurred()) SWIG_fail;
13977 }
13978 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13979 return resultobj;
13980 fail:
13981 return NULL;
13982 }
13983
13984
13985 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13986 PyObject *resultobj = 0;
13987 wxImage *arg1 = (wxImage *) 0 ;
13988 int arg2 ;
13989 int arg3 ;
13990 byte arg4 ;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 int val2 ;
13994 int ecode2 = 0 ;
13995 int val3 ;
13996 int ecode3 = 0 ;
13997 unsigned char val4 ;
13998 int ecode4 = 0 ;
13999 PyObject * obj0 = 0 ;
14000 PyObject * obj1 = 0 ;
14001 PyObject * obj2 = 0 ;
14002 PyObject * obj3 = 0 ;
14003 char * kwnames[] = {
14004 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14005 };
14006
14007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14009 if (!SWIG_IsOK(res1)) {
14010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14011 }
14012 arg1 = reinterpret_cast< wxImage * >(argp1);
14013 ecode2 = SWIG_AsVal_int(obj1, &val2);
14014 if (!SWIG_IsOK(ecode2)) {
14015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14016 }
14017 arg2 = static_cast< int >(val2);
14018 ecode3 = SWIG_AsVal_int(obj2, &val3);
14019 if (!SWIG_IsOK(ecode3)) {
14020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14021 }
14022 arg3 = static_cast< int >(val3);
14023 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14024 if (!SWIG_IsOK(ecode4)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14026 }
14027 arg4 = static_cast< byte >(val4);
14028 {
14029 PyThreadState* __tstate = wxPyBeginAllowThreads();
14030 (arg1)->SetAlpha(arg2,arg3,arg4);
14031 wxPyEndAllowThreads(__tstate);
14032 if (PyErr_Occurred()) SWIG_fail;
14033 }
14034 resultobj = SWIG_Py_Void();
14035 return resultobj;
14036 fail:
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxImage *arg1 = (wxImage *) 0 ;
14044 int arg2 ;
14045 int arg3 ;
14046 byte result;
14047 void *argp1 = 0 ;
14048 int res1 = 0 ;
14049 int val2 ;
14050 int ecode2 = 0 ;
14051 int val3 ;
14052 int ecode3 = 0 ;
14053 PyObject * obj0 = 0 ;
14054 PyObject * obj1 = 0 ;
14055 PyObject * obj2 = 0 ;
14056 char * kwnames[] = {
14057 (char *) "self",(char *) "x",(char *) "y", NULL
14058 };
14059
14060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14062 if (!SWIG_IsOK(res1)) {
14063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14064 }
14065 arg1 = reinterpret_cast< wxImage * >(argp1);
14066 ecode2 = SWIG_AsVal_int(obj1, &val2);
14067 if (!SWIG_IsOK(ecode2)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14069 }
14070 arg2 = static_cast< int >(val2);
14071 ecode3 = SWIG_AsVal_int(obj2, &val3);
14072 if (!SWIG_IsOK(ecode3)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14074 }
14075 arg3 = static_cast< int >(val3);
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14090 PyObject *resultobj = 0;
14091 wxImage *arg1 = (wxImage *) 0 ;
14092 bool result;
14093 void *argp1 = 0 ;
14094 int res1 = 0 ;
14095 PyObject *swig_obj[1] ;
14096
14097 if (!args) SWIG_fail;
14098 swig_obj[0] = args;
14099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14100 if (!SWIG_IsOK(res1)) {
14101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14102 }
14103 arg1 = reinterpret_cast< wxImage * >(argp1);
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 result = (bool)(arg1)->HasAlpha();
14107 wxPyEndAllowThreads(__tstate);
14108 if (PyErr_Occurred()) SWIG_fail;
14109 }
14110 {
14111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14112 }
14113 return resultobj;
14114 fail:
14115 return NULL;
14116 }
14117
14118
14119 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14120 PyObject *resultobj = 0;
14121 wxImage *arg1 = (wxImage *) 0 ;
14122 void *argp1 = 0 ;
14123 int res1 = 0 ;
14124 PyObject *swig_obj[1] ;
14125
14126 if (!args) SWIG_fail;
14127 swig_obj[0] = args;
14128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14131 }
14132 arg1 = reinterpret_cast< wxImage * >(argp1);
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 (arg1)->InitAlpha();
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 resultobj = SWIG_Py_Void();
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj = 0;
14148 wxImage *arg1 = (wxImage *) 0 ;
14149 int arg2 ;
14150 int arg3 ;
14151 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14152 bool result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 int val2 ;
14156 int ecode2 = 0 ;
14157 int val3 ;
14158 int ecode3 = 0 ;
14159 unsigned char val4 ;
14160 int ecode4 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 PyObject * obj2 = 0 ;
14164 PyObject * obj3 = 0 ;
14165 char * kwnames[] = {
14166 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14167 };
14168
14169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14171 if (!SWIG_IsOK(res1)) {
14172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14173 }
14174 arg1 = reinterpret_cast< wxImage * >(argp1);
14175 ecode2 = SWIG_AsVal_int(obj1, &val2);
14176 if (!SWIG_IsOK(ecode2)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14178 }
14179 arg2 = static_cast< int >(val2);
14180 ecode3 = SWIG_AsVal_int(obj2, &val3);
14181 if (!SWIG_IsOK(ecode3)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14183 }
14184 arg3 = static_cast< int >(val3);
14185 if (obj3) {
14186 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14187 if (!SWIG_IsOK(ecode4)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14189 }
14190 arg4 = static_cast< byte >(val4);
14191 }
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14200 }
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14208 PyObject *resultobj = 0;
14209 wxImage *arg1 = (wxImage *) 0 ;
14210 byte *arg2 = (byte *) 0 ;
14211 byte *arg3 = (byte *) 0 ;
14212 byte *arg4 = (byte *) 0 ;
14213 byte arg5 = (byte) 0 ;
14214 byte arg6 = (byte) 0 ;
14215 byte arg7 = (byte) 0 ;
14216 bool result;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 byte temp2 ;
14220 int res2 = SWIG_TMPOBJ ;
14221 byte temp3 ;
14222 int res3 = SWIG_TMPOBJ ;
14223 byte temp4 ;
14224 int res4 = SWIG_TMPOBJ ;
14225 unsigned char val5 ;
14226 int ecode5 = 0 ;
14227 unsigned char val6 ;
14228 int ecode6 = 0 ;
14229 unsigned char val7 ;
14230 int ecode7 = 0 ;
14231 PyObject * obj0 = 0 ;
14232 PyObject * obj1 = 0 ;
14233 PyObject * obj2 = 0 ;
14234 PyObject * obj3 = 0 ;
14235 char * kwnames[] = {
14236 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14237 };
14238
14239 arg2 = &temp2;
14240 arg3 = &temp3;
14241 arg4 = &temp4;
14242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14244 if (!SWIG_IsOK(res1)) {
14245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14246 }
14247 arg1 = reinterpret_cast< wxImage * >(argp1);
14248 if (obj1) {
14249 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14250 if (!SWIG_IsOK(ecode5)) {
14251 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14252 }
14253 arg5 = static_cast< byte >(val5);
14254 }
14255 if (obj2) {
14256 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14257 if (!SWIG_IsOK(ecode6)) {
14258 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14259 }
14260 arg6 = static_cast< byte >(val6);
14261 }
14262 if (obj3) {
14263 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14264 if (!SWIG_IsOK(ecode7)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14266 }
14267 arg7 = static_cast< byte >(val7);
14268 }
14269 {
14270 PyThreadState* __tstate = wxPyBeginAllowThreads();
14271 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 {
14276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14277 }
14278 if (SWIG_IsTmpObj(res2)) {
14279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14280 } else {
14281 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14283 }
14284 if (SWIG_IsTmpObj(res3)) {
14285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14286 } else {
14287 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14289 }
14290 if (SWIG_IsTmpObj(res4)) {
14291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14292 } else {
14293 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14295 }
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj = 0;
14304 wxImage *arg1 = (wxImage *) 0 ;
14305 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14306 bool result;
14307 void *argp1 = 0 ;
14308 int res1 = 0 ;
14309 unsigned char val2 ;
14310 int ecode2 = 0 ;
14311 PyObject * obj0 = 0 ;
14312 PyObject * obj1 = 0 ;
14313 char * kwnames[] = {
14314 (char *) "self",(char *) "threshold", NULL
14315 };
14316
14317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14319 if (!SWIG_IsOK(res1)) {
14320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14321 }
14322 arg1 = reinterpret_cast< wxImage * >(argp1);
14323 if (obj1) {
14324 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14325 if (!SWIG_IsOK(ecode2)) {
14326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14327 }
14328 arg2 = static_cast< byte >(val2);
14329 }
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 {
14337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14338 }
14339 return resultobj;
14340 fail:
14341 return NULL;
14342 }
14343
14344
14345 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj = 0;
14347 wxImage *arg1 = (wxImage *) 0 ;
14348 byte arg2 ;
14349 byte arg3 ;
14350 byte arg4 ;
14351 bool result;
14352 void *argp1 = 0 ;
14353 int res1 = 0 ;
14354 unsigned char val2 ;
14355 int ecode2 = 0 ;
14356 unsigned char val3 ;
14357 int ecode3 = 0 ;
14358 unsigned char val4 ;
14359 int ecode4 = 0 ;
14360 PyObject * obj0 = 0 ;
14361 PyObject * obj1 = 0 ;
14362 PyObject * obj2 = 0 ;
14363 PyObject * obj3 = 0 ;
14364 char * kwnames[] = {
14365 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14366 };
14367
14368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14372 }
14373 arg1 = reinterpret_cast< wxImage * >(argp1);
14374 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14375 if (!SWIG_IsOK(ecode2)) {
14376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14377 }
14378 arg2 = static_cast< byte >(val2);
14379 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14380 if (!SWIG_IsOK(ecode3)) {
14381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14382 }
14383 arg3 = static_cast< byte >(val3);
14384 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14385 if (!SWIG_IsOK(ecode4)) {
14386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14387 }
14388 arg4 = static_cast< byte >(val4);
14389 {
14390 PyThreadState* __tstate = wxPyBeginAllowThreads();
14391 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj = 0;
14406 wxImage *arg1 = (wxImage *) 0 ;
14407 wxImage *arg2 = 0 ;
14408 byte arg3 ;
14409 byte arg4 ;
14410 byte arg5 ;
14411 bool result;
14412 void *argp1 = 0 ;
14413 int res1 = 0 ;
14414 void *argp2 = 0 ;
14415 int res2 = 0 ;
14416 unsigned char val3 ;
14417 int ecode3 = 0 ;
14418 unsigned char val4 ;
14419 int ecode4 = 0 ;
14420 unsigned char val5 ;
14421 int ecode5 = 0 ;
14422 PyObject * obj0 = 0 ;
14423 PyObject * obj1 = 0 ;
14424 PyObject * obj2 = 0 ;
14425 PyObject * obj3 = 0 ;
14426 PyObject * obj4 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14435 }
14436 arg1 = reinterpret_cast< wxImage * >(argp1);
14437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14438 if (!SWIG_IsOK(res2)) {
14439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14440 }
14441 if (!argp2) {
14442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14443 }
14444 arg2 = reinterpret_cast< wxImage * >(argp2);
14445 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14446 if (!SWIG_IsOK(ecode3)) {
14447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14448 }
14449 arg3 = static_cast< byte >(val3);
14450 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14451 if (!SWIG_IsOK(ecode4)) {
14452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14453 }
14454 arg4 = static_cast< byte >(val4);
14455 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14456 if (!SWIG_IsOK(ecode5)) {
14457 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14458 }
14459 arg5 = static_cast< byte >(val5);
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 {
14467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14468 }
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj = 0;
14477 wxString *arg1 = 0 ;
14478 bool result;
14479 bool temp1 = false ;
14480 PyObject * obj0 = 0 ;
14481 char * kwnames[] = {
14482 (char *) "filename", NULL
14483 };
14484
14485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14486 {
14487 arg1 = wxString_in_helper(obj0);
14488 if (arg1 == NULL) SWIG_fail;
14489 temp1 = true;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 {
14498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14499 }
14500 {
14501 if (temp1)
14502 delete arg1;
14503 }
14504 return resultobj;
14505 fail:
14506 {
14507 if (temp1)
14508 delete arg1;
14509 }
14510 return NULL;
14511 }
14512
14513
14514 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14515 PyObject *resultobj = 0;
14516 wxString *arg1 = 0 ;
14517 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14518 int result;
14519 bool temp1 = false ;
14520 long val2 ;
14521 int ecode2 = 0 ;
14522 PyObject * obj0 = 0 ;
14523 PyObject * obj1 = 0 ;
14524 char * kwnames[] = {
14525 (char *) "filename",(char *) "type", NULL
14526 };
14527
14528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14529 {
14530 arg1 = wxString_in_helper(obj0);
14531 if (arg1 == NULL) SWIG_fail;
14532 temp1 = true;
14533 }
14534 if (obj1) {
14535 ecode2 = SWIG_AsVal_long(obj1, &val2);
14536 if (!SWIG_IsOK(ecode2)) {
14537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14538 }
14539 arg2 = static_cast< long >(val2);
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = SWIG_From_int(static_cast< int >(result));
14548 {
14549 if (temp1)
14550 delete arg1;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp1)
14556 delete arg1;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxImage *arg1 = (wxImage *) 0 ;
14565 wxString *arg2 = 0 ;
14566 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14567 int arg4 = (int) -1 ;
14568 bool result;
14569 void *argp1 = 0 ;
14570 int res1 = 0 ;
14571 bool temp2 = false ;
14572 long val3 ;
14573 int ecode3 = 0 ;
14574 int val4 ;
14575 int ecode4 = 0 ;
14576 PyObject * obj0 = 0 ;
14577 PyObject * obj1 = 0 ;
14578 PyObject * obj2 = 0 ;
14579 PyObject * obj3 = 0 ;
14580 char * kwnames[] = {
14581 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14582 };
14583
14584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14588 }
14589 arg1 = reinterpret_cast< wxImage * >(argp1);
14590 {
14591 arg2 = wxString_in_helper(obj1);
14592 if (arg2 == NULL) SWIG_fail;
14593 temp2 = true;
14594 }
14595 if (obj2) {
14596 ecode3 = SWIG_AsVal_long(obj2, &val3);
14597 if (!SWIG_IsOK(ecode3)) {
14598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14599 }
14600 arg3 = static_cast< long >(val3);
14601 }
14602 if (obj3) {
14603 ecode4 = SWIG_AsVal_int(obj3, &val4);
14604 if (!SWIG_IsOK(ecode4)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14606 }
14607 arg4 = static_cast< int >(val4);
14608 }
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 return resultobj;
14623 fail:
14624 {
14625 if (temp2)
14626 delete arg2;
14627 }
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = 0;
14634 wxImage *arg1 = (wxImage *) 0 ;
14635 wxString *arg2 = 0 ;
14636 wxString *arg3 = 0 ;
14637 int arg4 = (int) -1 ;
14638 bool result;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 bool temp2 = false ;
14642 bool temp3 = false ;
14643 int val4 ;
14644 int ecode4 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 PyObject * obj3 = 0 ;
14649 char * kwnames[] = {
14650 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14651 };
14652
14653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14655 if (!SWIG_IsOK(res1)) {
14656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14657 }
14658 arg1 = reinterpret_cast< wxImage * >(argp1);
14659 {
14660 arg2 = wxString_in_helper(obj1);
14661 if (arg2 == NULL) SWIG_fail;
14662 temp2 = true;
14663 }
14664 {
14665 arg3 = wxString_in_helper(obj2);
14666 if (arg3 == NULL) SWIG_fail;
14667 temp3 = true;
14668 }
14669 if (obj3) {
14670 ecode4 = SWIG_AsVal_int(obj3, &val4);
14671 if (!SWIG_IsOK(ecode4)) {
14672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14673 }
14674 arg4 = static_cast< int >(val4);
14675 }
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 {
14683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14684 }
14685 {
14686 if (temp2)
14687 delete arg2;
14688 }
14689 {
14690 if (temp3)
14691 delete arg3;
14692 }
14693 return resultobj;
14694 fail:
14695 {
14696 if (temp2)
14697 delete arg2;
14698 }
14699 {
14700 if (temp3)
14701 delete arg3;
14702 }
14703 return NULL;
14704 }
14705
14706
14707 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14708 PyObject *resultobj = 0;
14709 wxImage *arg1 = (wxImage *) 0 ;
14710 wxString *arg2 = 0 ;
14711 int arg3 ;
14712 bool result;
14713 void *argp1 = 0 ;
14714 int res1 = 0 ;
14715 bool temp2 = false ;
14716 int val3 ;
14717 int ecode3 = 0 ;
14718 PyObject * obj0 = 0 ;
14719 PyObject * obj1 = 0 ;
14720 PyObject * obj2 = 0 ;
14721 char * kwnames[] = {
14722 (char *) "self",(char *) "name",(char *) "type", NULL
14723 };
14724
14725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14727 if (!SWIG_IsOK(res1)) {
14728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14729 }
14730 arg1 = reinterpret_cast< wxImage * >(argp1);
14731 {
14732 arg2 = wxString_in_helper(obj1);
14733 if (arg2 == NULL) SWIG_fail;
14734 temp2 = true;
14735 }
14736 ecode3 = SWIG_AsVal_int(obj2, &val3);
14737 if (!SWIG_IsOK(ecode3)) {
14738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14739 }
14740 arg3 = static_cast< int >(val3);
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 {
14748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14749 }
14750 {
14751 if (temp2)
14752 delete arg2;
14753 }
14754 return resultobj;
14755 fail:
14756 {
14757 if (temp2)
14758 delete arg2;
14759 }
14760 return NULL;
14761 }
14762
14763
14764 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj = 0;
14766 wxImage *arg1 = (wxImage *) 0 ;
14767 wxString *arg2 = 0 ;
14768 wxString *arg3 = 0 ;
14769 bool result;
14770 void *argp1 = 0 ;
14771 int res1 = 0 ;
14772 bool temp2 = false ;
14773 bool temp3 = false ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 PyObject * obj2 = 0 ;
14777 char * kwnames[] = {
14778 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14779 };
14780
14781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14783 if (!SWIG_IsOK(res1)) {
14784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14785 }
14786 arg1 = reinterpret_cast< wxImage * >(argp1);
14787 {
14788 arg2 = wxString_in_helper(obj1);
14789 if (arg2 == NULL) SWIG_fail;
14790 temp2 = true;
14791 }
14792 {
14793 arg3 = wxString_in_helper(obj2);
14794 if (arg3 == NULL) SWIG_fail;
14795 temp3 = true;
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 {
14804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14805 }
14806 {
14807 if (temp2)
14808 delete arg2;
14809 }
14810 {
14811 if (temp3)
14812 delete arg3;
14813 }
14814 return resultobj;
14815 fail:
14816 {
14817 if (temp2)
14818 delete arg2;
14819 }
14820 {
14821 if (temp3)
14822 delete arg3;
14823 }
14824 return NULL;
14825 }
14826
14827
14828 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj = 0;
14830 wxInputStream *arg1 = 0 ;
14831 bool result;
14832 wxPyInputStream *temp1 ;
14833 bool created1 ;
14834 PyObject * obj0 = 0 ;
14835 char * kwnames[] = {
14836 (char *) "stream", NULL
14837 };
14838
14839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14840 {
14841 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14842 arg1 = temp1->m_wxis;
14843 created1 = false;
14844 } else {
14845 PyErr_Clear(); // clear the failure of the wxPyConvert above
14846 arg1 = wxPyCBInputStream_create(obj0, false);
14847 if (arg1 == NULL) {
14848 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14849 SWIG_fail;
14850 }
14851 created1 = true;
14852 }
14853 }
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 result = (bool)wxImage::CanRead(*arg1);
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 {
14861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14862 }
14863 {
14864 if (created1) delete arg1;
14865 }
14866 return resultobj;
14867 fail:
14868 {
14869 if (created1) delete arg1;
14870 }
14871 return NULL;
14872 }
14873
14874
14875 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14876 PyObject *resultobj = 0;
14877 wxImage *arg1 = (wxImage *) 0 ;
14878 wxInputStream *arg2 = 0 ;
14879 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14880 int arg4 = (int) -1 ;
14881 bool result;
14882 void *argp1 = 0 ;
14883 int res1 = 0 ;
14884 wxPyInputStream *temp2 ;
14885 bool created2 ;
14886 long val3 ;
14887 int ecode3 = 0 ;
14888 int val4 ;
14889 int ecode4 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 PyObject * obj3 = 0 ;
14894 char * kwnames[] = {
14895 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14896 };
14897
14898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14900 if (!SWIG_IsOK(res1)) {
14901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14902 }
14903 arg1 = reinterpret_cast< wxImage * >(argp1);
14904 {
14905 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14906 arg2 = temp2->m_wxis;
14907 created2 = false;
14908 } else {
14909 PyErr_Clear(); // clear the failure of the wxPyConvert above
14910 arg2 = wxPyCBInputStream_create(obj1, false);
14911 if (arg2 == NULL) {
14912 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14913 SWIG_fail;
14914 }
14915 created2 = true;
14916 }
14917 }
14918 if (obj2) {
14919 ecode3 = SWIG_AsVal_long(obj2, &val3);
14920 if (!SWIG_IsOK(ecode3)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14922 }
14923 arg3 = static_cast< long >(val3);
14924 }
14925 if (obj3) {
14926 ecode4 = SWIG_AsVal_int(obj3, &val4);
14927 if (!SWIG_IsOK(ecode4)) {
14928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14929 }
14930 arg4 = static_cast< int >(val4);
14931 }
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 {
14939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14940 }
14941 {
14942 if (created2) delete arg2;
14943 }
14944 return resultobj;
14945 fail:
14946 {
14947 if (created2) delete arg2;
14948 }
14949 return NULL;
14950 }
14951
14952
14953 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj = 0;
14955 wxImage *arg1 = (wxImage *) 0 ;
14956 wxInputStream *arg2 = 0 ;
14957 wxString *arg3 = 0 ;
14958 int arg4 = (int) -1 ;
14959 bool result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 wxPyInputStream *temp2 ;
14963 bool created2 ;
14964 bool temp3 = false ;
14965 int val4 ;
14966 int ecode4 = 0 ;
14967 PyObject * obj0 = 0 ;
14968 PyObject * obj1 = 0 ;
14969 PyObject * obj2 = 0 ;
14970 PyObject * obj3 = 0 ;
14971 char * kwnames[] = {
14972 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14973 };
14974
14975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14977 if (!SWIG_IsOK(res1)) {
14978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14979 }
14980 arg1 = reinterpret_cast< wxImage * >(argp1);
14981 {
14982 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14983 arg2 = temp2->m_wxis;
14984 created2 = false;
14985 } else {
14986 PyErr_Clear(); // clear the failure of the wxPyConvert above
14987 arg2 = wxPyCBInputStream_create(obj1, false);
14988 if (arg2 == NULL) {
14989 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14990 SWIG_fail;
14991 }
14992 created2 = true;
14993 }
14994 }
14995 {
14996 arg3 = wxString_in_helper(obj2);
14997 if (arg3 == NULL) SWIG_fail;
14998 temp3 = true;
14999 }
15000 if (obj3) {
15001 ecode4 = SWIG_AsVal_int(obj3, &val4);
15002 if (!SWIG_IsOK(ecode4)) {
15003 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15004 }
15005 arg4 = static_cast< int >(val4);
15006 }
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 {
15014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15015 }
15016 {
15017 if (created2) delete arg2;
15018 }
15019 {
15020 if (temp3)
15021 delete arg3;
15022 }
15023 return resultobj;
15024 fail:
15025 {
15026 if (created2) delete arg2;
15027 }
15028 {
15029 if (temp3)
15030 delete arg3;
15031 }
15032 return NULL;
15033 }
15034
15035
15036 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15037 PyObject *resultobj = 0;
15038 wxImage *arg1 = (wxImage *) 0 ;
15039 bool result;
15040 void *argp1 = 0 ;
15041 int res1 = 0 ;
15042 PyObject *swig_obj[1] ;
15043
15044 if (!args) SWIG_fail;
15045 swig_obj[0] = args;
15046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15047 if (!SWIG_IsOK(res1)) {
15048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15049 }
15050 arg1 = reinterpret_cast< wxImage * >(argp1);
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (bool)(arg1)->Ok();
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 {
15058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15059 }
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15067 PyObject *resultobj = 0;
15068 wxImage *arg1 = (wxImage *) 0 ;
15069 int result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 PyObject *swig_obj[1] ;
15073
15074 if (!args) SWIG_fail;
15075 swig_obj[0] = args;
15076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15077 if (!SWIG_IsOK(res1)) {
15078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15079 }
15080 arg1 = reinterpret_cast< wxImage * >(argp1);
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 result = (int)(arg1)->GetWidth();
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 resultobj = SWIG_From_int(static_cast< int >(result));
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15095 PyObject *resultobj = 0;
15096 wxImage *arg1 = (wxImage *) 0 ;
15097 int result;
15098 void *argp1 = 0 ;
15099 int res1 = 0 ;
15100 PyObject *swig_obj[1] ;
15101
15102 if (!args) SWIG_fail;
15103 swig_obj[0] = args;
15104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15105 if (!SWIG_IsOK(res1)) {
15106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15107 }
15108 arg1 = reinterpret_cast< wxImage * >(argp1);
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (int)(arg1)->GetHeight();
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 resultobj = SWIG_From_int(static_cast< int >(result));
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15123 PyObject *resultobj = 0;
15124 wxImage *arg1 = (wxImage *) 0 ;
15125 wxSize result;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 PyObject *swig_obj[1] ;
15129
15130 if (!args) SWIG_fail;
15131 swig_obj[0] = args;
15132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15135 }
15136 arg1 = reinterpret_cast< wxImage * >(argp1);
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = wxImage_GetSize(arg1);
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15144 return resultobj;
15145 fail:
15146 return NULL;
15147 }
15148
15149
15150 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj = 0;
15152 wxImage *arg1 = (wxImage *) 0 ;
15153 wxRect *arg2 = 0 ;
15154 SwigValueWrapper<wxImage > result;
15155 void *argp1 = 0 ;
15156 int res1 = 0 ;
15157 wxRect temp2 ;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 char * kwnames[] = {
15161 (char *) "self",(char *) "rect", NULL
15162 };
15163
15164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15166 if (!SWIG_IsOK(res1)) {
15167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15168 }
15169 arg1 = reinterpret_cast< wxImage * >(argp1);
15170 {
15171 arg2 = &temp2;
15172 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15173 }
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15188 PyObject *resultobj = 0;
15189 wxImage *arg1 = (wxImage *) 0 ;
15190 wxSize *arg2 = 0 ;
15191 wxPoint *arg3 = 0 ;
15192 int arg4 = (int) -1 ;
15193 int arg5 = (int) -1 ;
15194 int arg6 = (int) -1 ;
15195 SwigValueWrapper<wxImage > result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 wxSize temp2 ;
15199 wxPoint temp3 ;
15200 int val4 ;
15201 int ecode4 = 0 ;
15202 int val5 ;
15203 int ecode5 = 0 ;
15204 int val6 ;
15205 int ecode6 = 0 ;
15206 PyObject * obj0 = 0 ;
15207 PyObject * obj1 = 0 ;
15208 PyObject * obj2 = 0 ;
15209 PyObject * obj3 = 0 ;
15210 PyObject * obj4 = 0 ;
15211 PyObject * obj5 = 0 ;
15212 char * kwnames[] = {
15213 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15214 };
15215
15216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15218 if (!SWIG_IsOK(res1)) {
15219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15220 }
15221 arg1 = reinterpret_cast< wxImage * >(argp1);
15222 {
15223 arg2 = &temp2;
15224 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15225 }
15226 {
15227 arg3 = &temp3;
15228 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15229 }
15230 if (obj3) {
15231 ecode4 = SWIG_AsVal_int(obj3, &val4);
15232 if (!SWIG_IsOK(ecode4)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15234 }
15235 arg4 = static_cast< int >(val4);
15236 }
15237 if (obj4) {
15238 ecode5 = SWIG_AsVal_int(obj4, &val5);
15239 if (!SWIG_IsOK(ecode5)) {
15240 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15241 }
15242 arg5 = static_cast< int >(val5);
15243 }
15244 if (obj5) {
15245 ecode6 = SWIG_AsVal_int(obj5, &val6);
15246 if (!SWIG_IsOK(ecode6)) {
15247 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15248 }
15249 arg6 = static_cast< int >(val6);
15250 }
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15254 wxPyEndAllowThreads(__tstate);
15255 if (PyErr_Occurred()) SWIG_fail;
15256 }
15257 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15258 return resultobj;
15259 fail:
15260 return NULL;
15261 }
15262
15263
15264 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15265 PyObject *resultobj = 0;
15266 wxImage *arg1 = (wxImage *) 0 ;
15267 SwigValueWrapper<wxImage > result;
15268 void *argp1 = 0 ;
15269 int res1 = 0 ;
15270 PyObject *swig_obj[1] ;
15271
15272 if (!args) SWIG_fail;
15273 swig_obj[0] = args;
15274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15275 if (!SWIG_IsOK(res1)) {
15276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15277 }
15278 arg1 = reinterpret_cast< wxImage * >(argp1);
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 result = (arg1)->Copy();
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj = 0;
15294 wxImage *arg1 = (wxImage *) 0 ;
15295 wxImage *arg2 = 0 ;
15296 int arg3 ;
15297 int arg4 ;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 void *argp2 = 0 ;
15301 int res2 = 0 ;
15302 int val3 ;
15303 int ecode3 = 0 ;
15304 int val4 ;
15305 int ecode4 = 0 ;
15306 PyObject * obj0 = 0 ;
15307 PyObject * obj1 = 0 ;
15308 PyObject * obj2 = 0 ;
15309 PyObject * obj3 = 0 ;
15310 char * kwnames[] = {
15311 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15312 };
15313
15314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15316 if (!SWIG_IsOK(res1)) {
15317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15318 }
15319 arg1 = reinterpret_cast< wxImage * >(argp1);
15320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15321 if (!SWIG_IsOK(res2)) {
15322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15323 }
15324 if (!argp2) {
15325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15326 }
15327 arg2 = reinterpret_cast< wxImage * >(argp2);
15328 ecode3 = SWIG_AsVal_int(obj2, &val3);
15329 if (!SWIG_IsOK(ecode3)) {
15330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15331 }
15332 arg3 = static_cast< int >(val3);
15333 ecode4 = SWIG_AsVal_int(obj3, &val4);
15334 if (!SWIG_IsOK(ecode4)) {
15335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15336 }
15337 arg4 = static_cast< int >(val4);
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15341 wxPyEndAllowThreads(__tstate);
15342 if (PyErr_Occurred()) SWIG_fail;
15343 }
15344 resultobj = SWIG_Py_Void();
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15352 PyObject *resultobj = 0;
15353 wxImage *arg1 = (wxImage *) 0 ;
15354 PyObject *result = 0 ;
15355 void *argp1 = 0 ;
15356 int res1 = 0 ;
15357 PyObject *swig_obj[1] ;
15358
15359 if (!args) SWIG_fail;
15360 swig_obj[0] = args;
15361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15362 if (!SWIG_IsOK(res1)) {
15363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15364 }
15365 arg1 = reinterpret_cast< wxImage * >(argp1);
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (PyObject *)wxImage_GetData(arg1);
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 resultobj = result;
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15380 PyObject *resultobj = 0;
15381 wxImage *arg1 = (wxImage *) 0 ;
15382 buffer arg2 ;
15383 int arg3 ;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char * kwnames[] = {
15389 (char *) "self",(char *) "data", NULL
15390 };
15391
15392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 wxImage_SetData(arg1,arg2,arg3);
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 resultobj = SWIG_Py_Void();
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15415 PyObject *resultobj = 0;
15416 wxImage *arg1 = (wxImage *) 0 ;
15417 PyObject *result = 0 ;
15418 void *argp1 = 0 ;
15419 int res1 = 0 ;
15420 PyObject *swig_obj[1] ;
15421
15422 if (!args) SWIG_fail;
15423 swig_obj[0] = args;
15424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15427 }
15428 arg1 = reinterpret_cast< wxImage * >(argp1);
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = result;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15443 PyObject *resultobj = 0;
15444 wxImage *arg1 = (wxImage *) 0 ;
15445 buffer arg2 ;
15446 int arg3 ;
15447 void *argp1 = 0 ;
15448 int res1 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "data", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15459 }
15460 arg1 = reinterpret_cast< wxImage * >(argp1);
15461 {
15462 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15463 }
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 wxImage_SetDataBuffer(arg1,arg2,arg3);
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 resultobj = SWIG_Py_Void();
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxImage *arg1 = (wxImage *) 0 ;
15480 PyObject *result = 0 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 PyObject *swig_obj[1] ;
15484
15485 if (!args) SWIG_fail;
15486 swig_obj[0] = args;
15487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (PyObject *)wxImage_GetAlphaData(arg1);
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 resultobj = result;
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj = 0;
15507 wxImage *arg1 = (wxImage *) 0 ;
15508 buffer arg2 ;
15509 int arg3 ;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 char * kwnames[] = {
15515 (char *) "self",(char *) "alpha", NULL
15516 };
15517
15518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15520 if (!SWIG_IsOK(res1)) {
15521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15522 }
15523 arg1 = reinterpret_cast< wxImage * >(argp1);
15524 {
15525 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15526 }
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 wxImage_SetAlphaData(arg1,arg2,arg3);
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_Py_Void();
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15541 PyObject *resultobj = 0;
15542 wxImage *arg1 = (wxImage *) 0 ;
15543 PyObject *result = 0 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 PyObject *swig_obj[1] ;
15547
15548 if (!args) SWIG_fail;
15549 swig_obj[0] = args;
15550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15553 }
15554 arg1 = reinterpret_cast< wxImage * >(argp1);
15555 {
15556 PyThreadState* __tstate = wxPyBeginAllowThreads();
15557 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15558 wxPyEndAllowThreads(__tstate);
15559 if (PyErr_Occurred()) SWIG_fail;
15560 }
15561 resultobj = result;
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15569 PyObject *resultobj = 0;
15570 wxImage *arg1 = (wxImage *) 0 ;
15571 buffer arg2 ;
15572 int arg3 ;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 PyObject * obj0 = 0 ;
15576 PyObject * obj1 = 0 ;
15577 char * kwnames[] = {
15578 (char *) "self",(char *) "alpha", NULL
15579 };
15580
15581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15585 }
15586 arg1 = reinterpret_cast< wxImage * >(argp1);
15587 {
15588 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15593 wxPyEndAllowThreads(__tstate);
15594 if (PyErr_Occurred()) SWIG_fail;
15595 }
15596 resultobj = SWIG_Py_Void();
15597 return resultobj;
15598 fail:
15599 return NULL;
15600 }
15601
15602
15603 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15604 PyObject *resultobj = 0;
15605 wxImage *arg1 = (wxImage *) 0 ;
15606 byte arg2 ;
15607 byte arg3 ;
15608 byte arg4 ;
15609 void *argp1 = 0 ;
15610 int res1 = 0 ;
15611 unsigned char val2 ;
15612 int ecode2 = 0 ;
15613 unsigned char val3 ;
15614 int ecode3 = 0 ;
15615 unsigned char val4 ;
15616 int ecode4 = 0 ;
15617 PyObject * obj0 = 0 ;
15618 PyObject * obj1 = 0 ;
15619 PyObject * obj2 = 0 ;
15620 PyObject * obj3 = 0 ;
15621 char * kwnames[] = {
15622 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15623 };
15624
15625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15627 if (!SWIG_IsOK(res1)) {
15628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15629 }
15630 arg1 = reinterpret_cast< wxImage * >(argp1);
15631 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15632 if (!SWIG_IsOK(ecode2)) {
15633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15634 }
15635 arg2 = static_cast< byte >(val2);
15636 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15637 if (!SWIG_IsOK(ecode3)) {
15638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15639 }
15640 arg3 = static_cast< byte >(val3);
15641 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15642 if (!SWIG_IsOK(ecode4)) {
15643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15644 }
15645 arg4 = static_cast< byte >(val4);
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 (arg1)->SetMaskColour(arg2,arg3,arg4);
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 resultobj = SWIG_Py_Void();
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15660 PyObject *resultobj = 0;
15661 wxImage *arg1 = (wxImage *) 0 ;
15662 byte *arg2 = (byte *) 0 ;
15663 byte *arg3 = (byte *) 0 ;
15664 byte *arg4 = (byte *) 0 ;
15665 void *argp1 = 0 ;
15666 int res1 = 0 ;
15667 byte temp2 ;
15668 int res2 = SWIG_TMPOBJ ;
15669 byte temp3 ;
15670 int res3 = SWIG_TMPOBJ ;
15671 byte temp4 ;
15672 int res4 = SWIG_TMPOBJ ;
15673 PyObject *swig_obj[1] ;
15674
15675 arg2 = &temp2;
15676 arg3 = &temp3;
15677 arg4 = &temp4;
15678 if (!args) SWIG_fail;
15679 swig_obj[0] = args;
15680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15681 if (!SWIG_IsOK(res1)) {
15682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15683 }
15684 arg1 = reinterpret_cast< wxImage * >(argp1);
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_Py_Void();
15692 if (SWIG_IsTmpObj(res2)) {
15693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15694 } else {
15695 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15697 }
15698 if (SWIG_IsTmpObj(res3)) {
15699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15700 } else {
15701 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15703 }
15704 if (SWIG_IsTmpObj(res4)) {
15705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15706 } else {
15707 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15709 }
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15717 PyObject *resultobj = 0;
15718 wxImage *arg1 = (wxImage *) 0 ;
15719 byte result;
15720 void *argp1 = 0 ;
15721 int res1 = 0 ;
15722 PyObject *swig_obj[1] ;
15723
15724 if (!args) SWIG_fail;
15725 swig_obj[0] = args;
15726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15727 if (!SWIG_IsOK(res1)) {
15728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15729 }
15730 arg1 = reinterpret_cast< wxImage * >(argp1);
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 result = (byte)(arg1)->GetMaskRed();
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745 PyObject *resultobj = 0;
15746 wxImage *arg1 = (wxImage *) 0 ;
15747 byte result;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 PyObject *swig_obj[1] ;
15751
15752 if (!args) SWIG_fail;
15753 swig_obj[0] = args;
15754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15755 if (!SWIG_IsOK(res1)) {
15756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15757 }
15758 arg1 = reinterpret_cast< wxImage * >(argp1);
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 result = (byte)(arg1)->GetMaskGreen();
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15773 PyObject *resultobj = 0;
15774 wxImage *arg1 = (wxImage *) 0 ;
15775 byte result;
15776 void *argp1 = 0 ;
15777 int res1 = 0 ;
15778 PyObject *swig_obj[1] ;
15779
15780 if (!args) SWIG_fail;
15781 swig_obj[0] = args;
15782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15783 if (!SWIG_IsOK(res1)) {
15784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15785 }
15786 arg1 = reinterpret_cast< wxImage * >(argp1);
15787 {
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 result = (byte)(arg1)->GetMaskBlue();
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15801 PyObject *resultobj = 0;
15802 wxImage *arg1 = (wxImage *) 0 ;
15803 bool arg2 = (bool) true ;
15804 void *argp1 = 0 ;
15805 int res1 = 0 ;
15806 bool val2 ;
15807 int ecode2 = 0 ;
15808 PyObject * obj0 = 0 ;
15809 PyObject * obj1 = 0 ;
15810 char * kwnames[] = {
15811 (char *) "self",(char *) "mask", NULL
15812 };
15813
15814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15816 if (!SWIG_IsOK(res1)) {
15817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15818 }
15819 arg1 = reinterpret_cast< wxImage * >(argp1);
15820 if (obj1) {
15821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15822 if (!SWIG_IsOK(ecode2)) {
15823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15824 }
15825 arg2 = static_cast< bool >(val2);
15826 }
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 (arg1)->SetMask(arg2);
15830 wxPyEndAllowThreads(__tstate);
15831 if (PyErr_Occurred()) SWIG_fail;
15832 }
15833 resultobj = SWIG_Py_Void();
15834 return resultobj;
15835 fail:
15836 return NULL;
15837 }
15838
15839
15840 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15841 PyObject *resultobj = 0;
15842 wxImage *arg1 = (wxImage *) 0 ;
15843 bool result;
15844 void *argp1 = 0 ;
15845 int res1 = 0 ;
15846 PyObject *swig_obj[1] ;
15847
15848 if (!args) SWIG_fail;
15849 swig_obj[0] = args;
15850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15851 if (!SWIG_IsOK(res1)) {
15852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15853 }
15854 arg1 = reinterpret_cast< wxImage * >(argp1);
15855 {
15856 PyThreadState* __tstate = wxPyBeginAllowThreads();
15857 result = (bool)(arg1)->HasMask();
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 {
15862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15863 }
15864 return resultobj;
15865 fail:
15866 return NULL;
15867 }
15868
15869
15870 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15871 PyObject *resultobj = 0;
15872 wxImage *arg1 = (wxImage *) 0 ;
15873 double arg2 ;
15874 wxPoint *arg3 = 0 ;
15875 bool arg4 = (bool) true ;
15876 wxPoint *arg5 = (wxPoint *) NULL ;
15877 SwigValueWrapper<wxImage > result;
15878 void *argp1 = 0 ;
15879 int res1 = 0 ;
15880 double val2 ;
15881 int ecode2 = 0 ;
15882 wxPoint temp3 ;
15883 bool val4 ;
15884 int ecode4 = 0 ;
15885 void *argp5 = 0 ;
15886 int res5 = 0 ;
15887 PyObject * obj0 = 0 ;
15888 PyObject * obj1 = 0 ;
15889 PyObject * obj2 = 0 ;
15890 PyObject * obj3 = 0 ;
15891 PyObject * obj4 = 0 ;
15892 char * kwnames[] = {
15893 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15894 };
15895
15896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15898 if (!SWIG_IsOK(res1)) {
15899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15900 }
15901 arg1 = reinterpret_cast< wxImage * >(argp1);
15902 ecode2 = SWIG_AsVal_double(obj1, &val2);
15903 if (!SWIG_IsOK(ecode2)) {
15904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15905 }
15906 arg2 = static_cast< double >(val2);
15907 {
15908 arg3 = &temp3;
15909 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15910 }
15911 if (obj3) {
15912 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15913 if (!SWIG_IsOK(ecode4)) {
15914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15915 }
15916 arg4 = static_cast< bool >(val4);
15917 }
15918 if (obj4) {
15919 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15920 if (!SWIG_IsOK(res5)) {
15921 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15922 }
15923 arg5 = reinterpret_cast< wxPoint * >(argp5);
15924 }
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj = 0;
15940 wxImage *arg1 = (wxImage *) 0 ;
15941 bool arg2 = (bool) true ;
15942 SwigValueWrapper<wxImage > result;
15943 void *argp1 = 0 ;
15944 int res1 = 0 ;
15945 bool val2 ;
15946 int ecode2 = 0 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 char * kwnames[] = {
15950 (char *) "self",(char *) "clockwise", NULL
15951 };
15952
15953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15955 if (!SWIG_IsOK(res1)) {
15956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15957 }
15958 arg1 = reinterpret_cast< wxImage * >(argp1);
15959 if (obj1) {
15960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15961 if (!SWIG_IsOK(ecode2)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15963 }
15964 arg2 = static_cast< bool >(val2);
15965 }
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 result = (arg1)->Rotate90(arg2);
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj = 0;
15981 wxImage *arg1 = (wxImage *) 0 ;
15982 bool arg2 = (bool) true ;
15983 SwigValueWrapper<wxImage > result;
15984 void *argp1 = 0 ;
15985 int res1 = 0 ;
15986 bool val2 ;
15987 int ecode2 = 0 ;
15988 PyObject * obj0 = 0 ;
15989 PyObject * obj1 = 0 ;
15990 char * kwnames[] = {
15991 (char *) "self",(char *) "horizontally", NULL
15992 };
15993
15994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15996 if (!SWIG_IsOK(res1)) {
15997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15998 }
15999 arg1 = reinterpret_cast< wxImage * >(argp1);
16000 if (obj1) {
16001 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16002 if (!SWIG_IsOK(ecode2)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16004 }
16005 arg2 = static_cast< bool >(val2);
16006 }
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (arg1)->Mirror(arg2);
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16021 PyObject *resultobj = 0;
16022 wxImage *arg1 = (wxImage *) 0 ;
16023 byte arg2 ;
16024 byte arg3 ;
16025 byte arg4 ;
16026 byte arg5 ;
16027 byte arg6 ;
16028 byte arg7 ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 unsigned char val2 ;
16032 int ecode2 = 0 ;
16033 unsigned char val3 ;
16034 int ecode3 = 0 ;
16035 unsigned char val4 ;
16036 int ecode4 = 0 ;
16037 unsigned char val5 ;
16038 int ecode5 = 0 ;
16039 unsigned char val6 ;
16040 int ecode6 = 0 ;
16041 unsigned char val7 ;
16042 int ecode7 = 0 ;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 PyObject * obj2 = 0 ;
16046 PyObject * obj3 = 0 ;
16047 PyObject * obj4 = 0 ;
16048 PyObject * obj5 = 0 ;
16049 PyObject * obj6 = 0 ;
16050 char * kwnames[] = {
16051 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16052 };
16053
16054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16058 }
16059 arg1 = reinterpret_cast< wxImage * >(argp1);
16060 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16061 if (!SWIG_IsOK(ecode2)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16063 }
16064 arg2 = static_cast< byte >(val2);
16065 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16066 if (!SWIG_IsOK(ecode3)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16068 }
16069 arg3 = static_cast< byte >(val3);
16070 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16071 if (!SWIG_IsOK(ecode4)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16073 }
16074 arg4 = static_cast< byte >(val4);
16075 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16076 if (!SWIG_IsOK(ecode5)) {
16077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16078 }
16079 arg5 = static_cast< byte >(val5);
16080 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16081 if (!SWIG_IsOK(ecode6)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16083 }
16084 arg6 = static_cast< byte >(val6);
16085 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16086 if (!SWIG_IsOK(ecode7)) {
16087 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16088 }
16089 arg7 = static_cast< byte >(val7);
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = SWIG_Py_Void();
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxImage *arg1 = (wxImage *) 0 ;
16106 double arg2 = (double) 0.299 ;
16107 double arg3 = (double) 0.587 ;
16108 double arg4 = (double) 0.114 ;
16109 SwigValueWrapper<wxImage > result;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 double val2 ;
16113 int ecode2 = 0 ;
16114 double val3 ;
16115 int ecode3 = 0 ;
16116 double val4 ;
16117 int ecode4 = 0 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 PyObject * obj2 = 0 ;
16121 PyObject * obj3 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16130 }
16131 arg1 = reinterpret_cast< wxImage * >(argp1);
16132 if (obj1) {
16133 ecode2 = SWIG_AsVal_double(obj1, &val2);
16134 if (!SWIG_IsOK(ecode2)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16136 }
16137 arg2 = static_cast< double >(val2);
16138 }
16139 if (obj2) {
16140 ecode3 = SWIG_AsVal_double(obj2, &val3);
16141 if (!SWIG_IsOK(ecode3)) {
16142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16143 }
16144 arg3 = static_cast< double >(val3);
16145 }
16146 if (obj3) {
16147 ecode4 = SWIG_AsVal_double(obj3, &val4);
16148 if (!SWIG_IsOK(ecode4)) {
16149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16150 }
16151 arg4 = static_cast< double >(val4);
16152 }
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16167 PyObject *resultobj = 0;
16168 wxImage *arg1 = (wxImage *) 0 ;
16169 byte arg2 ;
16170 byte arg3 ;
16171 byte arg4 ;
16172 SwigValueWrapper<wxImage > result;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 unsigned char val2 ;
16176 int ecode2 = 0 ;
16177 unsigned char val3 ;
16178 int ecode3 = 0 ;
16179 unsigned char val4 ;
16180 int ecode4 = 0 ;
16181 PyObject * obj0 = 0 ;
16182 PyObject * obj1 = 0 ;
16183 PyObject * obj2 = 0 ;
16184 PyObject * obj3 = 0 ;
16185 char * kwnames[] = {
16186 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16187 };
16188
16189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16191 if (!SWIG_IsOK(res1)) {
16192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16193 }
16194 arg1 = reinterpret_cast< wxImage * >(argp1);
16195 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16196 if (!SWIG_IsOK(ecode2)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16198 }
16199 arg2 = static_cast< byte >(val2);
16200 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16201 if (!SWIG_IsOK(ecode3)) {
16202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16203 }
16204 arg3 = static_cast< byte >(val3);
16205 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16206 if (!SWIG_IsOK(ecode4)) {
16207 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16208 }
16209 arg4 = static_cast< byte >(val4);
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj = 0;
16225 wxImage *arg1 = (wxImage *) 0 ;
16226 wxString *arg2 = 0 ;
16227 wxString *arg3 = 0 ;
16228 void *argp1 = 0 ;
16229 int res1 = 0 ;
16230 bool temp2 = false ;
16231 bool temp3 = false ;
16232 PyObject * obj0 = 0 ;
16233 PyObject * obj1 = 0 ;
16234 PyObject * obj2 = 0 ;
16235 char * kwnames[] = {
16236 (char *) "self",(char *) "name",(char *) "value", NULL
16237 };
16238
16239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16241 if (!SWIG_IsOK(res1)) {
16242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16243 }
16244 arg1 = reinterpret_cast< wxImage * >(argp1);
16245 {
16246 arg2 = wxString_in_helper(obj1);
16247 if (arg2 == NULL) SWIG_fail;
16248 temp2 = true;
16249 }
16250 {
16251 arg3 = wxString_in_helper(obj2);
16252 if (arg3 == NULL) SWIG_fail;
16253 temp3 = true;
16254 }
16255 {
16256 PyThreadState* __tstate = wxPyBeginAllowThreads();
16257 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16258 wxPyEndAllowThreads(__tstate);
16259 if (PyErr_Occurred()) SWIG_fail;
16260 }
16261 resultobj = SWIG_Py_Void();
16262 {
16263 if (temp2)
16264 delete arg2;
16265 }
16266 {
16267 if (temp3)
16268 delete arg3;
16269 }
16270 return resultobj;
16271 fail:
16272 {
16273 if (temp2)
16274 delete arg2;
16275 }
16276 {
16277 if (temp3)
16278 delete arg3;
16279 }
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16285 PyObject *resultobj = 0;
16286 wxImage *arg1 = (wxImage *) 0 ;
16287 wxString *arg2 = 0 ;
16288 int arg3 ;
16289 void *argp1 = 0 ;
16290 int res1 = 0 ;
16291 bool temp2 = false ;
16292 int val3 ;
16293 int ecode3 = 0 ;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 PyObject * obj2 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "name",(char *) "value", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16305 }
16306 arg1 = reinterpret_cast< wxImage * >(argp1);
16307 {
16308 arg2 = wxString_in_helper(obj1);
16309 if (arg2 == NULL) SWIG_fail;
16310 temp2 = true;
16311 }
16312 ecode3 = SWIG_AsVal_int(obj2, &val3);
16313 if (!SWIG_IsOK(ecode3)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16315 }
16316 arg3 = static_cast< int >(val3);
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 (arg1)->SetOption((wxString const &)*arg2,arg3);
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 resultobj = SWIG_Py_Void();
16324 {
16325 if (temp2)
16326 delete arg2;
16327 }
16328 return resultobj;
16329 fail:
16330 {
16331 if (temp2)
16332 delete arg2;
16333 }
16334 return NULL;
16335 }
16336
16337
16338 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16339 PyObject *resultobj = 0;
16340 wxImage *arg1 = (wxImage *) 0 ;
16341 wxString *arg2 = 0 ;
16342 wxString result;
16343 void *argp1 = 0 ;
16344 int res1 = 0 ;
16345 bool temp2 = false ;
16346 PyObject * obj0 = 0 ;
16347 PyObject * obj1 = 0 ;
16348 char * kwnames[] = {
16349 (char *) "self",(char *) "name", NULL
16350 };
16351
16352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16354 if (!SWIG_IsOK(res1)) {
16355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16356 }
16357 arg1 = reinterpret_cast< wxImage * >(argp1);
16358 {
16359 arg2 = wxString_in_helper(obj1);
16360 if (arg2 == NULL) SWIG_fail;
16361 temp2 = true;
16362 }
16363 {
16364 PyThreadState* __tstate = wxPyBeginAllowThreads();
16365 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 {
16370 #if wxUSE_UNICODE
16371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16372 #else
16373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16374 #endif
16375 }
16376 {
16377 if (temp2)
16378 delete arg2;
16379 }
16380 return resultobj;
16381 fail:
16382 {
16383 if (temp2)
16384 delete arg2;
16385 }
16386 return NULL;
16387 }
16388
16389
16390 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16391 PyObject *resultobj = 0;
16392 wxImage *arg1 = (wxImage *) 0 ;
16393 wxString *arg2 = 0 ;
16394 int result;
16395 void *argp1 = 0 ;
16396 int res1 = 0 ;
16397 bool temp2 = false ;
16398 PyObject * obj0 = 0 ;
16399 PyObject * obj1 = 0 ;
16400 char * kwnames[] = {
16401 (char *) "self",(char *) "name", NULL
16402 };
16403
16404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16406 if (!SWIG_IsOK(res1)) {
16407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16408 }
16409 arg1 = reinterpret_cast< wxImage * >(argp1);
16410 {
16411 arg2 = wxString_in_helper(obj1);
16412 if (arg2 == NULL) SWIG_fail;
16413 temp2 = true;
16414 }
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 resultobj = SWIG_From_int(static_cast< int >(result));
16422 {
16423 if (temp2)
16424 delete arg2;
16425 }
16426 return resultobj;
16427 fail:
16428 {
16429 if (temp2)
16430 delete arg2;
16431 }
16432 return NULL;
16433 }
16434
16435
16436 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16437 PyObject *resultobj = 0;
16438 wxImage *arg1 = (wxImage *) 0 ;
16439 wxString *arg2 = 0 ;
16440 bool result;
16441 void *argp1 = 0 ;
16442 int res1 = 0 ;
16443 bool temp2 = false ;
16444 PyObject * obj0 = 0 ;
16445 PyObject * obj1 = 0 ;
16446 char * kwnames[] = {
16447 (char *) "self",(char *) "name", NULL
16448 };
16449
16450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16454 }
16455 arg1 = reinterpret_cast< wxImage * >(argp1);
16456 {
16457 arg2 = wxString_in_helper(obj1);
16458 if (arg2 == NULL) SWIG_fail;
16459 temp2 = true;
16460 }
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 {
16468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16469 }
16470 {
16471 if (temp2)
16472 delete arg2;
16473 }
16474 return resultobj;
16475 fail:
16476 {
16477 if (temp2)
16478 delete arg2;
16479 }
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj = 0;
16486 wxImage *arg1 = (wxImage *) 0 ;
16487 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16488 unsigned long result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 unsigned long val2 ;
16492 int ecode2 = 0 ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 char * kwnames[] = {
16496 (char *) "self",(char *) "stopafter", NULL
16497 };
16498
16499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16501 if (!SWIG_IsOK(res1)) {
16502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16503 }
16504 arg1 = reinterpret_cast< wxImage * >(argp1);
16505 if (obj1) {
16506 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16507 if (!SWIG_IsOK(ecode2)) {
16508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16509 }
16510 arg2 = static_cast< unsigned long >(val2);
16511 }
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (unsigned long)(arg1)->CountColours(arg2);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxImage *arg1 = (wxImage *) 0 ;
16528 wxImageHistogram *arg2 = 0 ;
16529 unsigned long result;
16530 void *argp1 = 0 ;
16531 int res1 = 0 ;
16532 void *argp2 = 0 ;
16533 int res2 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 char * kwnames[] = {
16537 (char *) "self",(char *) "h", NULL
16538 };
16539
16540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16542 if (!SWIG_IsOK(res1)) {
16543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16544 }
16545 arg1 = reinterpret_cast< wxImage * >(argp1);
16546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16547 if (!SWIG_IsOK(res2)) {
16548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16549 }
16550 if (!argp2) {
16551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16552 }
16553 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj = 0;
16569 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16570 void *argp1 = 0 ;
16571 int res1 = 0 ;
16572 PyObject * obj0 = 0 ;
16573 char * kwnames[] = {
16574 (char *) "handler", NULL
16575 };
16576
16577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16579 if (!SWIG_IsOK(res1)) {
16580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16581 }
16582 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 wxImage::AddHandler(arg1);
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 resultobj = SWIG_Py_Void();
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj = 0;
16598 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16599 void *argp1 = 0 ;
16600 int res1 = 0 ;
16601 PyObject * obj0 = 0 ;
16602 char * kwnames[] = {
16603 (char *) "handler", NULL
16604 };
16605
16606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16608 if (!SWIG_IsOK(res1)) {
16609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16610 }
16611 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16612 {
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 wxImage::InsertHandler(arg1);
16615 wxPyEndAllowThreads(__tstate);
16616 if (PyErr_Occurred()) SWIG_fail;
16617 }
16618 resultobj = SWIG_Py_Void();
16619 return resultobj;
16620 fail:
16621 return NULL;
16622 }
16623
16624
16625 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16626 PyObject *resultobj = 0;
16627 wxString *arg1 = 0 ;
16628 bool result;
16629 bool temp1 = false ;
16630 PyObject * obj0 = 0 ;
16631 char * kwnames[] = {
16632 (char *) "name", NULL
16633 };
16634
16635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16636 {
16637 arg1 = wxString_in_helper(obj0);
16638 if (arg1 == NULL) SWIG_fail;
16639 temp1 = true;
16640 }
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 {
16648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16649 }
16650 {
16651 if (temp1)
16652 delete arg1;
16653 }
16654 return resultobj;
16655 fail:
16656 {
16657 if (temp1)
16658 delete arg1;
16659 }
16660 return NULL;
16661 }
16662
16663
16664 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16665 PyObject *resultobj = 0;
16666 PyObject *result = 0 ;
16667
16668 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (PyObject *)wxImage_GetHandlers();
16672 wxPyEndAllowThreads(__tstate);
16673 if (PyErr_Occurred()) SWIG_fail;
16674 }
16675 resultobj = result;
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16683 PyObject *resultobj = 0;
16684 wxString result;
16685
16686 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = wxImage::GetImageExtWildcard();
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 {
16694 #if wxUSE_UNICODE
16695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16696 #else
16697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16698 #endif
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj = 0;
16708 wxImage *arg1 = (wxImage *) 0 ;
16709 int arg2 = (int) -1 ;
16710 wxBitmap result;
16711 void *argp1 = 0 ;
16712 int res1 = 0 ;
16713 int val2 ;
16714 int ecode2 = 0 ;
16715 PyObject * obj0 = 0 ;
16716 PyObject * obj1 = 0 ;
16717 char * kwnames[] = {
16718 (char *) "self",(char *) "depth", NULL
16719 };
16720
16721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16723 if (!SWIG_IsOK(res1)) {
16724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16725 }
16726 arg1 = reinterpret_cast< wxImage * >(argp1);
16727 if (obj1) {
16728 ecode2 = SWIG_AsVal_int(obj1, &val2);
16729 if (!SWIG_IsOK(ecode2)) {
16730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16731 }
16732 arg2 = static_cast< int >(val2);
16733 }
16734 {
16735 if (!wxPyCheckForApp()) SWIG_fail;
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = wxImage_ConvertToBitmap(arg1,arg2);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 byte arg2 ;
16752 byte arg3 ;
16753 byte arg4 ;
16754 wxBitmap result;
16755 void *argp1 = 0 ;
16756 int res1 = 0 ;
16757 unsigned char val2 ;
16758 int ecode2 = 0 ;
16759 unsigned char val3 ;
16760 int ecode3 = 0 ;
16761 unsigned char val4 ;
16762 int ecode4 = 0 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 PyObject * obj2 = 0 ;
16766 PyObject * obj3 = 0 ;
16767 char * kwnames[] = {
16768 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16769 };
16770
16771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16775 }
16776 arg1 = reinterpret_cast< wxImage * >(argp1);
16777 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16778 if (!SWIG_IsOK(ecode2)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16780 }
16781 arg2 = static_cast< byte >(val2);
16782 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16783 if (!SWIG_IsOK(ecode3)) {
16784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16785 }
16786 arg3 = static_cast< byte >(val3);
16787 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16788 if (!SWIG_IsOK(ecode4)) {
16789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16790 }
16791 arg4 = static_cast< byte >(val4);
16792 {
16793 if (!wxPyCheckForApp()) SWIG_fail;
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj = 0;
16808 wxImage *arg1 = (wxImage *) 0 ;
16809 double arg2 ;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 double val2 ;
16813 int ecode2 = 0 ;
16814 PyObject * obj0 = 0 ;
16815 PyObject * obj1 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "angle", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16824 }
16825 arg1 = reinterpret_cast< wxImage * >(argp1);
16826 ecode2 = SWIG_AsVal_double(obj1, &val2);
16827 if (!SWIG_IsOK(ecode2)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16829 }
16830 arg2 = static_cast< double >(val2);
16831 {
16832 PyThreadState* __tstate = wxPyBeginAllowThreads();
16833 (arg1)->RotateHue(arg2);
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 resultobj = SWIG_Py_Void();
16838 return resultobj;
16839 fail:
16840 return NULL;
16841 }
16842
16843
16844 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16845 PyObject *resultobj = 0;
16846 wxImage_RGBValue arg1 ;
16847 wxImage_HSVValue result;
16848 void *argp1 ;
16849 int res1 = 0 ;
16850 PyObject * obj0 = 0 ;
16851 char * kwnames[] = {
16852 (char *) "rgb", NULL
16853 };
16854
16855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16856 {
16857 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16858 if (!SWIG_IsOK(res1)) {
16859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16860 }
16861 if (!argp1) {
16862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16863 } else {
16864 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16865 arg1 = *temp;
16866 if (SWIG_IsNewObj(res1)) delete temp;
16867 }
16868 }
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = wxImage::RGBtoHSV(arg1);
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj = 0;
16884 wxImage_HSVValue arg1 ;
16885 wxImage_RGBValue result;
16886 void *argp1 ;
16887 int res1 = 0 ;
16888 PyObject * obj0 = 0 ;
16889 char * kwnames[] = {
16890 (char *) "hsv", NULL
16891 };
16892
16893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16894 {
16895 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16898 }
16899 if (!argp1) {
16900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16901 } else {
16902 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16903 arg1 = *temp;
16904 if (SWIG_IsNewObj(res1)) delete temp;
16905 }
16906 }
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = wxImage::HSVtoRGB(arg1);
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16921 PyObject *obj;
16922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16923 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16924 return SWIG_Py_Void();
16925 }
16926
16927 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16928 return SWIG_Python_InitShadowInstance(args);
16929 }
16930
16931 SWIGINTERN int NullImage_set(PyObject *) {
16932 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16933 return 1;
16934 }
16935
16936
16937 SWIGINTERN PyObject *NullImage_get(void) {
16938 PyObject *pyobj = 0;
16939
16940 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16941 return pyobj;
16942 }
16943
16944
16945 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16946 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16947 return 1;
16948 }
16949
16950
16951 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16952 PyObject *pyobj = 0;
16953
16954 {
16955 #if wxUSE_UNICODE
16956 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16957 #else
16958 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16959 #endif
16960 }
16961 return pyobj;
16962 }
16963
16964
16965 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16966 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16967 return 1;
16968 }
16969
16970
16971 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16972 PyObject *pyobj = 0;
16973
16974 {
16975 #if wxUSE_UNICODE
16976 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16977 #else
16978 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16979 #endif
16980 }
16981 return pyobj;
16982 }
16983
16984
16985 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16986 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16987 return 1;
16988 }
16989
16990
16991 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16992 PyObject *pyobj = 0;
16993
16994 {
16995 #if wxUSE_UNICODE
16996 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16997 #else
16998 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16999 #endif
17000 }
17001 return pyobj;
17002 }
17003
17004
17005 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17006 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17007 return 1;
17008 }
17009
17010
17011 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17012 PyObject *pyobj = 0;
17013
17014 {
17015 #if wxUSE_UNICODE
17016 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17017 #else
17018 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17019 #endif
17020 }
17021 return pyobj;
17022 }
17023
17024
17025 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17026 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17027 return 1;
17028 }
17029
17030
17031 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17032 PyObject *pyobj = 0;
17033
17034 {
17035 #if wxUSE_UNICODE
17036 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17037 #else
17038 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17039 #endif
17040 }
17041 return pyobj;
17042 }
17043
17044
17045 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17046 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17047 return 1;
17048 }
17049
17050
17051 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17052 PyObject *pyobj = 0;
17053
17054 {
17055 #if wxUSE_UNICODE
17056 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17057 #else
17058 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17059 #endif
17060 }
17061 return pyobj;
17062 }
17063
17064
17065 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17066 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17067 return 1;
17068 }
17069
17070
17071 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17072 PyObject *pyobj = 0;
17073
17074 {
17075 #if wxUSE_UNICODE
17076 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17077 #else
17078 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17079 #endif
17080 }
17081 return pyobj;
17082 }
17083
17084
17085 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17086 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17087 return 1;
17088 }
17089
17090
17091 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17092 PyObject *pyobj = 0;
17093
17094 {
17095 #if wxUSE_UNICODE
17096 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17097 #else
17098 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17099 #endif
17100 }
17101 return pyobj;
17102 }
17103
17104
17105 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17106 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17107 return 1;
17108 }
17109
17110
17111 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17112 PyObject *pyobj = 0;
17113
17114 {
17115 #if wxUSE_UNICODE
17116 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17117 #else
17118 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17119 #endif
17120 }
17121 return pyobj;
17122 }
17123
17124
17125 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17126 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17127 return 1;
17128 }
17129
17130
17131 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17132 PyObject *pyobj = 0;
17133
17134 {
17135 #if wxUSE_UNICODE
17136 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17137 #else
17138 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17139 #endif
17140 }
17141 return pyobj;
17142 }
17143
17144
17145 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17146 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17147 return 1;
17148 }
17149
17150
17151 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17152 PyObject *pyobj = 0;
17153
17154 {
17155 #if wxUSE_UNICODE
17156 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17157 #else
17158 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17159 #endif
17160 }
17161 return pyobj;
17162 }
17163
17164
17165 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17166 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17167 return 1;
17168 }
17169
17170
17171 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17172 PyObject *pyobj = 0;
17173
17174 {
17175 #if wxUSE_UNICODE
17176 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17177 #else
17178 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17179 #endif
17180 }
17181 return pyobj;
17182 }
17183
17184
17185 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17186 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17187 return 1;
17188 }
17189
17190
17191 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17192 PyObject *pyobj = 0;
17193
17194 {
17195 #if wxUSE_UNICODE
17196 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17197 #else
17198 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17199 #endif
17200 }
17201 return pyobj;
17202 }
17203
17204
17205 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17206 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17207 return 1;
17208 }
17209
17210
17211 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17212 PyObject *pyobj = 0;
17213
17214 {
17215 #if wxUSE_UNICODE
17216 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17217 #else
17218 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17219 #endif
17220 }
17221 return pyobj;
17222 }
17223
17224
17225 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17226 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17227 return 1;
17228 }
17229
17230
17231 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17232 PyObject *pyobj = 0;
17233
17234 {
17235 #if wxUSE_UNICODE
17236 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17237 #else
17238 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17239 #endif
17240 }
17241 return pyobj;
17242 }
17243
17244
17245 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17246 PyObject *resultobj = 0;
17247 wxBMPHandler *result = 0 ;
17248
17249 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (wxBMPHandler *)new wxBMPHandler();
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 PyObject *obj;
17265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17266 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17267 return SWIG_Py_Void();
17268 }
17269
17270 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17271 return SWIG_Python_InitShadowInstance(args);
17272 }
17273
17274 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17275 PyObject *resultobj = 0;
17276 wxICOHandler *result = 0 ;
17277
17278 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (wxICOHandler *)new wxICOHandler();
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 PyObject *obj;
17294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17295 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17296 return SWIG_Py_Void();
17297 }
17298
17299 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17300 return SWIG_Python_InitShadowInstance(args);
17301 }
17302
17303 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17304 PyObject *resultobj = 0;
17305 wxCURHandler *result = 0 ;
17306
17307 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17308 {
17309 PyThreadState* __tstate = wxPyBeginAllowThreads();
17310 result = (wxCURHandler *)new wxCURHandler();
17311 wxPyEndAllowThreads(__tstate);
17312 if (PyErr_Occurred()) SWIG_fail;
17313 }
17314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 PyObject *obj;
17323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17324 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17325 return SWIG_Py_Void();
17326 }
17327
17328 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 return SWIG_Python_InitShadowInstance(args);
17330 }
17331
17332 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 PyObject *resultobj = 0;
17334 wxANIHandler *result = 0 ;
17335
17336 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = (wxANIHandler *)new wxANIHandler();
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 PyObject *obj;
17352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17353 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17354 return SWIG_Py_Void();
17355 }
17356
17357 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 return SWIG_Python_InitShadowInstance(args);
17359 }
17360
17361 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 PyObject *resultobj = 0;
17363 wxPNGHandler *result = 0 ;
17364
17365 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (wxPNGHandler *)new wxPNGHandler();
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 PyObject *obj;
17381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17382 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17383 return SWIG_Py_Void();
17384 }
17385
17386 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 return SWIG_Python_InitShadowInstance(args);
17388 }
17389
17390 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17391 PyObject *resultobj = 0;
17392 wxGIFHandler *result = 0 ;
17393
17394 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17395 {
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = (wxGIFHandler *)new wxGIFHandler();
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17402 return resultobj;
17403 fail:
17404 return NULL;
17405 }
17406
17407
17408 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17409 PyObject *obj;
17410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17411 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17412 return SWIG_Py_Void();
17413 }
17414
17415 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416 return SWIG_Python_InitShadowInstance(args);
17417 }
17418
17419 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17420 PyObject *resultobj = 0;
17421 wxPCXHandler *result = 0 ;
17422
17423 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (wxPCXHandler *)new wxPCXHandler();
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17431 return resultobj;
17432 fail:
17433 return NULL;
17434 }
17435
17436
17437 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438 PyObject *obj;
17439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17441 return SWIG_Py_Void();
17442 }
17443
17444 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 return SWIG_Python_InitShadowInstance(args);
17446 }
17447
17448 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17449 PyObject *resultobj = 0;
17450 wxJPEGHandler *result = 0 ;
17451
17452 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17453 {
17454 PyThreadState* __tstate = wxPyBeginAllowThreads();
17455 result = (wxJPEGHandler *)new wxJPEGHandler();
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 PyObject *obj;
17468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17469 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17470 return SWIG_Py_Void();
17471 }
17472
17473 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17474 return SWIG_Python_InitShadowInstance(args);
17475 }
17476
17477 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17478 PyObject *resultobj = 0;
17479 wxPNMHandler *result = 0 ;
17480
17481 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (wxPNMHandler *)new wxPNMHandler();
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17496 PyObject *obj;
17497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17498 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17499 return SWIG_Py_Void();
17500 }
17501
17502 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17503 return SWIG_Python_InitShadowInstance(args);
17504 }
17505
17506 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17507 PyObject *resultobj = 0;
17508 wxXPMHandler *result = 0 ;
17509
17510 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (wxXPMHandler *)new wxXPMHandler();
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17525 PyObject *obj;
17526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17527 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17528 return SWIG_Py_Void();
17529 }
17530
17531 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 return SWIG_Python_InitShadowInstance(args);
17533 }
17534
17535 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17536 PyObject *resultobj = 0;
17537 wxTIFFHandler *result = 0 ;
17538
17539 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (wxTIFFHandler *)new wxTIFFHandler();
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17554 PyObject *obj;
17555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17556 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17557 return SWIG_Py_Void();
17558 }
17559
17560 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17561 return SWIG_Python_InitShadowInstance(args);
17562 }
17563
17564 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj = 0;
17566 wxImage *arg1 = 0 ;
17567 wxImage *arg2 = 0 ;
17568 int arg3 = (int) 236 ;
17569 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17570 bool result;
17571 void *argp1 = 0 ;
17572 int res1 = 0 ;
17573 void *argp2 = 0 ;
17574 int res2 = 0 ;
17575 int val3 ;
17576 int ecode3 = 0 ;
17577 int val4 ;
17578 int ecode4 = 0 ;
17579 PyObject * obj0 = 0 ;
17580 PyObject * obj1 = 0 ;
17581 PyObject * obj2 = 0 ;
17582 PyObject * obj3 = 0 ;
17583 char * kwnames[] = {
17584 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17585 };
17586
17587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17588 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17589 if (!SWIG_IsOK(res1)) {
17590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17591 }
17592 if (!argp1) {
17593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17594 }
17595 arg1 = reinterpret_cast< wxImage * >(argp1);
17596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17597 if (!SWIG_IsOK(res2)) {
17598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17599 }
17600 if (!argp2) {
17601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17602 }
17603 arg2 = reinterpret_cast< wxImage * >(argp2);
17604 if (obj2) {
17605 ecode3 = SWIG_AsVal_int(obj2, &val3);
17606 if (!SWIG_IsOK(ecode3)) {
17607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17608 }
17609 arg3 = static_cast< int >(val3);
17610 }
17611 if (obj3) {
17612 ecode4 = SWIG_AsVal_int(obj3, &val4);
17613 if (!SWIG_IsOK(ecode4)) {
17614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17615 }
17616 arg4 = static_cast< int >(val4);
17617 }
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 {
17625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17626 }
17627 return resultobj;
17628 fail:
17629 return NULL;
17630 }
17631
17632
17633 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17634 PyObject *obj;
17635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17636 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17637 return SWIG_Py_Void();
17638 }
17639
17640 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17641 PyObject *resultobj = 0;
17642 wxEvtHandler *result = 0 ;
17643
17644 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (wxEvtHandler *)new wxEvtHandler();
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17659 PyObject *resultobj = 0;
17660 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17661 wxEvtHandler *result = 0 ;
17662 void *argp1 = 0 ;
17663 int res1 = 0 ;
17664 PyObject *swig_obj[1] ;
17665
17666 if (!args) SWIG_fail;
17667 swig_obj[0] = args;
17668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17671 }
17672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17673 {
17674 PyThreadState* __tstate = wxPyBeginAllowThreads();
17675 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17676 wxPyEndAllowThreads(__tstate);
17677 if (PyErr_Occurred()) SWIG_fail;
17678 }
17679 {
17680 resultobj = wxPyMake_wxObject(result, 0);
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17691 wxEvtHandler *result = 0 ;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 PyObject *swig_obj[1] ;
17695
17696 if (!args) SWIG_fail;
17697 swig_obj[0] = args;
17698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17699 if (!SWIG_IsOK(res1)) {
17700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17701 }
17702 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17703 {
17704 PyThreadState* __tstate = wxPyBeginAllowThreads();
17705 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = wxPyMake_wxObject(result, 0);
17711 }
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj = 0;
17720 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17721 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17722 void *argp1 = 0 ;
17723 int res1 = 0 ;
17724 void *argp2 = 0 ;
17725 int res2 = 0 ;
17726 PyObject * obj0 = 0 ;
17727 PyObject * obj1 = 0 ;
17728 char * kwnames[] = {
17729 (char *) "self",(char *) "handler", NULL
17730 };
17731
17732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17734 if (!SWIG_IsOK(res1)) {
17735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17736 }
17737 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17739 if (!SWIG_IsOK(res2)) {
17740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17741 }
17742 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 (arg1)->SetNextHandler(arg2);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 resultobj = SWIG_Py_Void();
17750 return resultobj;
17751 fail:
17752 return NULL;
17753 }
17754
17755
17756 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj = 0;
17758 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17759 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17760 void *argp1 = 0 ;
17761 int res1 = 0 ;
17762 void *argp2 = 0 ;
17763 int res2 = 0 ;
17764 PyObject * obj0 = 0 ;
17765 PyObject * obj1 = 0 ;
17766 char * kwnames[] = {
17767 (char *) "self",(char *) "handler", NULL
17768 };
17769
17770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17774 }
17775 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17777 if (!SWIG_IsOK(res2)) {
17778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17779 }
17780 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 (arg1)->SetPreviousHandler(arg2);
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 resultobj = SWIG_Py_Void();
17788 return resultobj;
17789 fail:
17790 return NULL;
17791 }
17792
17793
17794 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17795 PyObject *resultobj = 0;
17796 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17797 bool result;
17798 void *argp1 = 0 ;
17799 int res1 = 0 ;
17800 PyObject *swig_obj[1] ;
17801
17802 if (!args) SWIG_fail;
17803 swig_obj[0] = args;
17804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17805 if (!SWIG_IsOK(res1)) {
17806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17807 }
17808 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)(arg1)->GetEvtHandlerEnabled();
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 return resultobj;
17819 fail:
17820 return NULL;
17821 }
17822
17823
17824 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17825 PyObject *resultobj = 0;
17826 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17827 bool arg2 ;
17828 void *argp1 = 0 ;
17829 int res1 = 0 ;
17830 bool val2 ;
17831 int ecode2 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char * kwnames[] = {
17835 (char *) "self",(char *) "enabled", NULL
17836 };
17837
17838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17842 }
17843 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17845 if (!SWIG_IsOK(ecode2)) {
17846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17847 }
17848 arg2 = static_cast< bool >(val2);
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 (arg1)->SetEvtHandlerEnabled(arg2);
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 resultobj = SWIG_Py_Void();
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj = 0;
17864 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17865 wxEvent *arg2 = 0 ;
17866 bool result;
17867 void *argp1 = 0 ;
17868 int res1 = 0 ;
17869 void *argp2 = 0 ;
17870 int res2 = 0 ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char * kwnames[] = {
17874 (char *) "self",(char *) "event", NULL
17875 };
17876
17877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17879 if (!SWIG_IsOK(res1)) {
17880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17881 }
17882 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17884 if (!SWIG_IsOK(res2)) {
17885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17886 }
17887 if (!argp2) {
17888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17889 }
17890 arg2 = reinterpret_cast< wxEvent * >(argp2);
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (bool)(arg1)->ProcessEvent(*arg2);
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 {
17898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17899 }
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj = 0;
17908 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17909 wxEvent *arg2 = 0 ;
17910 void *argp1 = 0 ;
17911 int res1 = 0 ;
17912 void *argp2 = 0 ;
17913 int res2 = 0 ;
17914 PyObject * obj0 = 0 ;
17915 PyObject * obj1 = 0 ;
17916 char * kwnames[] = {
17917 (char *) "self",(char *) "event", NULL
17918 };
17919
17920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17922 if (!SWIG_IsOK(res1)) {
17923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17924 }
17925 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17927 if (!SWIG_IsOK(res2)) {
17928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17929 }
17930 if (!argp2) {
17931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17932 }
17933 arg2 = reinterpret_cast< wxEvent * >(argp2);
17934 {
17935 PyThreadState* __tstate = wxPyBeginAllowThreads();
17936 (arg1)->AddPendingEvent(*arg2);
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 resultobj = SWIG_Py_Void();
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 PyObject *swig_obj[1] ;
17953
17954 if (!args) SWIG_fail;
17955 swig_obj[0] = args;
17956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17959 }
17960 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 (arg1)->ProcessPendingEvents();
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 resultobj = SWIG_Py_Void();
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj = 0;
17976 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17977 int arg2 ;
17978 int arg3 ;
17979 int arg4 ;
17980 PyObject *arg5 = (PyObject *) 0 ;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 int val2 ;
17984 int ecode2 = 0 ;
17985 int val3 ;
17986 int ecode3 = 0 ;
17987 int val4 ;
17988 int ecode4 = 0 ;
17989 PyObject * obj0 = 0 ;
17990 PyObject * obj1 = 0 ;
17991 PyObject * obj2 = 0 ;
17992 PyObject * obj3 = 0 ;
17993 PyObject * obj4 = 0 ;
17994 char * kwnames[] = {
17995 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17996 };
17997
17998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18000 if (!SWIG_IsOK(res1)) {
18001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18002 }
18003 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18004 ecode2 = SWIG_AsVal_int(obj1, &val2);
18005 if (!SWIG_IsOK(ecode2)) {
18006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18007 }
18008 arg2 = static_cast< int >(val2);
18009 ecode3 = SWIG_AsVal_int(obj2, &val3);
18010 if (!SWIG_IsOK(ecode3)) {
18011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18012 }
18013 arg3 = static_cast< int >(val3);
18014 ecode4 = SWIG_AsVal_int(obj3, &val4);
18015 if (!SWIG_IsOK(ecode4)) {
18016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18017 }
18018 arg4 = static_cast< int >(val4);
18019 arg5 = obj4;
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 resultobj = SWIG_Py_Void();
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj = 0;
18035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18036 int arg2 ;
18037 int arg3 = (int) -1 ;
18038 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18039 bool result;
18040 void *argp1 = 0 ;
18041 int res1 = 0 ;
18042 int val2 ;
18043 int ecode2 = 0 ;
18044 int val3 ;
18045 int ecode3 = 0 ;
18046 int val4 ;
18047 int ecode4 = 0 ;
18048 PyObject * obj0 = 0 ;
18049 PyObject * obj1 = 0 ;
18050 PyObject * obj2 = 0 ;
18051 PyObject * obj3 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18060 }
18061 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18062 ecode2 = SWIG_AsVal_int(obj1, &val2);
18063 if (!SWIG_IsOK(ecode2)) {
18064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18065 }
18066 arg2 = static_cast< int >(val2);
18067 if (obj2) {
18068 ecode3 = SWIG_AsVal_int(obj2, &val3);
18069 if (!SWIG_IsOK(ecode3)) {
18070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18071 }
18072 arg3 = static_cast< int >(val3);
18073 }
18074 if (obj3) {
18075 ecode4 = SWIG_AsVal_int(obj3, &val4);
18076 if (!SWIG_IsOK(ecode4)) {
18077 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18078 }
18079 arg4 = static_cast< wxEventType >(val4);
18080 }
18081 {
18082 PyThreadState* __tstate = wxPyBeginAllowThreads();
18083 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18084 wxPyEndAllowThreads(__tstate);
18085 if (PyErr_Occurred()) SWIG_fail;
18086 }
18087 {
18088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18089 }
18090 return resultobj;
18091 fail:
18092 return NULL;
18093 }
18094
18095
18096 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18097 PyObject *resultobj = 0;
18098 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18099 PyObject *arg2 = (PyObject *) 0 ;
18100 bool arg3 = (bool) true ;
18101 void *argp1 = 0 ;
18102 int res1 = 0 ;
18103 bool val3 ;
18104 int ecode3 = 0 ;
18105 PyObject * obj0 = 0 ;
18106 PyObject * obj1 = 0 ;
18107 PyObject * obj2 = 0 ;
18108 char * kwnames[] = {
18109 (char *) "self",(char *) "_self",(char *) "incref", NULL
18110 };
18111
18112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18118 arg2 = obj1;
18119 if (obj2) {
18120 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18121 if (!SWIG_IsOK(ecode3)) {
18122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18123 }
18124 arg3 = static_cast< bool >(val3);
18125 }
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 resultobj = SWIG_Py_Void();
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18140 PyObject *obj;
18141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18142 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18143 return SWIG_Py_Void();
18144 }
18145
18146 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 return SWIG_Python_InitShadowInstance(args);
18148 }
18149
18150 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18151 PyObject *resultobj = 0;
18152 wxEventType result;
18153
18154 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18155 {
18156 PyThreadState* __tstate = wxPyBeginAllowThreads();
18157 result = (wxEventType)wxNewEventType();
18158 wxPyEndAllowThreads(__tstate);
18159 if (PyErr_Occurred()) SWIG_fail;
18160 }
18161 resultobj = SWIG_From_int(static_cast< int >(result));
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18169 PyObject *resultobj = 0;
18170 wxEvent *arg1 = (wxEvent *) 0 ;
18171 void *argp1 = 0 ;
18172 int res1 = 0 ;
18173 PyObject *swig_obj[1] ;
18174
18175 if (!args) SWIG_fail;
18176 swig_obj[0] = args;
18177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18180 }
18181 arg1 = reinterpret_cast< wxEvent * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 delete arg1;
18185
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_Py_Void();
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj = 0;
18198 wxEvent *arg1 = (wxEvent *) 0 ;
18199 wxEventType arg2 ;
18200 void *argp1 = 0 ;
18201 int res1 = 0 ;
18202 int val2 ;
18203 int ecode2 = 0 ;
18204 PyObject * obj0 = 0 ;
18205 PyObject * obj1 = 0 ;
18206 char * kwnames[] = {
18207 (char *) "self",(char *) "typ", NULL
18208 };
18209
18210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18212 if (!SWIG_IsOK(res1)) {
18213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18214 }
18215 arg1 = reinterpret_cast< wxEvent * >(argp1);
18216 ecode2 = SWIG_AsVal_int(obj1, &val2);
18217 if (!SWIG_IsOK(ecode2)) {
18218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18219 }
18220 arg2 = static_cast< wxEventType >(val2);
18221 {
18222 PyThreadState* __tstate = wxPyBeginAllowThreads();
18223 (arg1)->SetEventType(arg2);
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 resultobj = SWIG_Py_Void();
18228 return resultobj;
18229 fail:
18230 return NULL;
18231 }
18232
18233
18234 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18235 PyObject *resultobj = 0;
18236 wxEvent *arg1 = (wxEvent *) 0 ;
18237 wxEventType result;
18238 void *argp1 = 0 ;
18239 int res1 = 0 ;
18240 PyObject *swig_obj[1] ;
18241
18242 if (!args) SWIG_fail;
18243 swig_obj[0] = args;
18244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvent * >(argp1);
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 resultobj = SWIG_From_int(static_cast< int >(result));
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18263 PyObject *resultobj = 0;
18264 wxEvent *arg1 = (wxEvent *) 0 ;
18265 wxObject *result = 0 ;
18266 void *argp1 = 0 ;
18267 int res1 = 0 ;
18268 PyObject *swig_obj[1] ;
18269
18270 if (!args) SWIG_fail;
18271 swig_obj[0] = args;
18272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18273 if (!SWIG_IsOK(res1)) {
18274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18275 }
18276 arg1 = reinterpret_cast< wxEvent * >(argp1);
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 {
18284 resultobj = wxPyMake_wxObject(result, (bool)0);
18285 }
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18293 PyObject *resultobj = 0;
18294 wxEvent *arg1 = (wxEvent *) 0 ;
18295 wxObject *arg2 = (wxObject *) 0 ;
18296 void *argp1 = 0 ;
18297 int res1 = 0 ;
18298 void *argp2 = 0 ;
18299 int res2 = 0 ;
18300 PyObject * obj0 = 0 ;
18301 PyObject * obj1 = 0 ;
18302 char * kwnames[] = {
18303 (char *) "self",(char *) "obj", NULL
18304 };
18305
18306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18308 if (!SWIG_IsOK(res1)) {
18309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18310 }
18311 arg1 = reinterpret_cast< wxEvent * >(argp1);
18312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18313 if (!SWIG_IsOK(res2)) {
18314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18315 }
18316 arg2 = reinterpret_cast< wxObject * >(argp2);
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 (arg1)->SetEventObject(arg2);
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 resultobj = SWIG_Py_Void();
18324 return resultobj;
18325 fail:
18326 return NULL;
18327 }
18328
18329
18330 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18331 PyObject *resultobj = 0;
18332 wxEvent *arg1 = (wxEvent *) 0 ;
18333 long result;
18334 void *argp1 = 0 ;
18335 int res1 = 0 ;
18336 PyObject *swig_obj[1] ;
18337
18338 if (!args) SWIG_fail;
18339 swig_obj[0] = args;
18340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18343 }
18344 arg1 = reinterpret_cast< wxEvent * >(argp1);
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_From_long(static_cast< long >(result));
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj = 0;
18360 wxEvent *arg1 = (wxEvent *) 0 ;
18361 long arg2 = (long) 0 ;
18362 void *argp1 = 0 ;
18363 int res1 = 0 ;
18364 long val2 ;
18365 int ecode2 = 0 ;
18366 PyObject * obj0 = 0 ;
18367 PyObject * obj1 = 0 ;
18368 char * kwnames[] = {
18369 (char *) "self",(char *) "ts", NULL
18370 };
18371
18372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18376 }
18377 arg1 = reinterpret_cast< wxEvent * >(argp1);
18378 if (obj1) {
18379 ecode2 = SWIG_AsVal_long(obj1, &val2);
18380 if (!SWIG_IsOK(ecode2)) {
18381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18382 }
18383 arg2 = static_cast< long >(val2);
18384 }
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 (arg1)->SetTimestamp(arg2);
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = SWIG_Py_Void();
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18399 PyObject *resultobj = 0;
18400 wxEvent *arg1 = (wxEvent *) 0 ;
18401 int result;
18402 void *argp1 = 0 ;
18403 int res1 = 0 ;
18404 PyObject *swig_obj[1] ;
18405
18406 if (!args) SWIG_fail;
18407 swig_obj[0] = args;
18408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18409 if (!SWIG_IsOK(res1)) {
18410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18411 }
18412 arg1 = reinterpret_cast< wxEvent * >(argp1);
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (int)((wxEvent const *)arg1)->GetId();
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_From_int(static_cast< int >(result));
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxEvent *arg1 = (wxEvent *) 0 ;
18429 int arg2 ;
18430 void *argp1 = 0 ;
18431 int res1 = 0 ;
18432 int val2 ;
18433 int ecode2 = 0 ;
18434 PyObject * obj0 = 0 ;
18435 PyObject * obj1 = 0 ;
18436 char * kwnames[] = {
18437 (char *) "self",(char *) "Id", NULL
18438 };
18439
18440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 ecode2 = SWIG_AsVal_int(obj1, &val2);
18447 if (!SWIG_IsOK(ecode2)) {
18448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18449 }
18450 arg2 = static_cast< int >(val2);
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 (arg1)->SetId(arg2);
18454 wxPyEndAllowThreads(__tstate);
18455 if (PyErr_Occurred()) SWIG_fail;
18456 }
18457 resultobj = SWIG_Py_Void();
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18465 PyObject *resultobj = 0;
18466 wxEvent *arg1 = (wxEvent *) 0 ;
18467 bool result;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 PyObject *swig_obj[1] ;
18471
18472 if (!args) SWIG_fail;
18473 swig_obj[0] = args;
18474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18477 }
18478 arg1 = reinterpret_cast< wxEvent * >(argp1);
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 {
18486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18487 }
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj = 0;
18496 wxEvent *arg1 = (wxEvent *) 0 ;
18497 bool arg2 = (bool) true ;
18498 void *argp1 = 0 ;
18499 int res1 = 0 ;
18500 bool val2 ;
18501 int ecode2 = 0 ;
18502 PyObject * obj0 = 0 ;
18503 PyObject * obj1 = 0 ;
18504 char * kwnames[] = {
18505 (char *) "self",(char *) "skip", NULL
18506 };
18507
18508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18512 }
18513 arg1 = reinterpret_cast< wxEvent * >(argp1);
18514 if (obj1) {
18515 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18516 if (!SWIG_IsOK(ecode2)) {
18517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18518 }
18519 arg2 = static_cast< bool >(val2);
18520 }
18521 {
18522 PyThreadState* __tstate = wxPyBeginAllowThreads();
18523 (arg1)->Skip(arg2);
18524 wxPyEndAllowThreads(__tstate);
18525 if (PyErr_Occurred()) SWIG_fail;
18526 }
18527 resultobj = SWIG_Py_Void();
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18535 PyObject *resultobj = 0;
18536 wxEvent *arg1 = (wxEvent *) 0 ;
18537 bool result;
18538 void *argp1 = 0 ;
18539 int res1 = 0 ;
18540 PyObject *swig_obj[1] ;
18541
18542 if (!args) SWIG_fail;
18543 swig_obj[0] = args;
18544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18545 if (!SWIG_IsOK(res1)) {
18546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18547 }
18548 arg1 = reinterpret_cast< wxEvent * >(argp1);
18549 {
18550 PyThreadState* __tstate = wxPyBeginAllowThreads();
18551 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 {
18556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18557 }
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18565 PyObject *resultobj = 0;
18566 wxEvent *arg1 = (wxEvent *) 0 ;
18567 bool result;
18568 void *argp1 = 0 ;
18569 int res1 = 0 ;
18570 PyObject *swig_obj[1] ;
18571
18572 if (!args) SWIG_fail;
18573 swig_obj[0] = args;
18574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18577 }
18578 arg1 = reinterpret_cast< wxEvent * >(argp1);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 {
18586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxEvent *arg1 = (wxEvent *) 0 ;
18597 int result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18607 }
18608 arg1 = reinterpret_cast< wxEvent * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (int)(arg1)->StopPropagation();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_int(static_cast< int >(result));
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxEvent *arg1 = (wxEvent *) 0 ;
18625 int arg2 ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 int val2 ;
18629 int ecode2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "propagationLevel", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvent * >(argp1);
18642 ecode2 = SWIG_AsVal_int(obj1, &val2);
18643 if (!SWIG_IsOK(ecode2)) {
18644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18645 }
18646 arg2 = static_cast< int >(val2);
18647 {
18648 PyThreadState* __tstate = wxPyBeginAllowThreads();
18649 (arg1)->ResumePropagation(arg2);
18650 wxPyEndAllowThreads(__tstate);
18651 if (PyErr_Occurred()) SWIG_fail;
18652 }
18653 resultobj = SWIG_Py_Void();
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18661 PyObject *resultobj = 0;
18662 wxEvent *arg1 = (wxEvent *) 0 ;
18663 wxEvent *result = 0 ;
18664 void *argp1 = 0 ;
18665 int res1 = 0 ;
18666 PyObject *swig_obj[1] ;
18667
18668 if (!args) SWIG_fail;
18669 swig_obj[0] = args;
18670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18673 }
18674 arg1 = reinterpret_cast< wxEvent * >(argp1);
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 result = (wxEvent *)(arg1)->Clone();
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18682 return resultobj;
18683 fail:
18684 return NULL;
18685 }
18686
18687
18688 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18689 PyObject *obj;
18690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18691 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18692 return SWIG_Py_Void();
18693 }
18694
18695 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj = 0;
18697 wxEvent *arg1 = 0 ;
18698 wxPropagationDisabler *result = 0 ;
18699 void *argp1 = 0 ;
18700 int res1 = 0 ;
18701 PyObject * obj0 = 0 ;
18702 char * kwnames[] = {
18703 (char *) "event", NULL
18704 };
18705
18706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18707 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18708 if (!SWIG_IsOK(res1)) {
18709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18710 }
18711 if (!argp1) {
18712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18713 }
18714 arg1 = reinterpret_cast< wxEvent * >(argp1);
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18729 PyObject *resultobj = 0;
18730 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18731 void *argp1 = 0 ;
18732 int res1 = 0 ;
18733 PyObject *swig_obj[1] ;
18734
18735 if (!args) SWIG_fail;
18736 swig_obj[0] = args;
18737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18740 }
18741 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18742 {
18743 PyThreadState* __tstate = wxPyBeginAllowThreads();
18744 delete arg1;
18745
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 resultobj = SWIG_Py_Void();
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18757 PyObject *obj;
18758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18759 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18760 return SWIG_Py_Void();
18761 }
18762
18763 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 return SWIG_Python_InitShadowInstance(args);
18765 }
18766
18767 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18768 PyObject *resultobj = 0;
18769 wxEvent *arg1 = 0 ;
18770 wxPropagateOnce *result = 0 ;
18771 void *argp1 = 0 ;
18772 int res1 = 0 ;
18773 PyObject * obj0 = 0 ;
18774 char * kwnames[] = {
18775 (char *) "event", NULL
18776 };
18777
18778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18779 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18780 if (!SWIG_IsOK(res1)) {
18781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18782 }
18783 if (!argp1) {
18784 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18785 }
18786 arg1 = reinterpret_cast< wxEvent * >(argp1);
18787 {
18788 PyThreadState* __tstate = wxPyBeginAllowThreads();
18789 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18801 PyObject *resultobj = 0;
18802 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 PyObject *swig_obj[1] ;
18806
18807 if (!args) SWIG_fail;
18808 swig_obj[0] = args;
18809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18810 if (!SWIG_IsOK(res1)) {
18811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18812 }
18813 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 delete arg1;
18817
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 resultobj = SWIG_Py_Void();
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18829 PyObject *obj;
18830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18831 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18832 return SWIG_Py_Void();
18833 }
18834
18835 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18836 return SWIG_Python_InitShadowInstance(args);
18837 }
18838
18839 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj = 0;
18841 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18842 int arg2 = (int) 0 ;
18843 wxCommandEvent *result = 0 ;
18844 int val1 ;
18845 int ecode1 = 0 ;
18846 int val2 ;
18847 int ecode2 = 0 ;
18848 PyObject * obj0 = 0 ;
18849 PyObject * obj1 = 0 ;
18850 char * kwnames[] = {
18851 (char *) "commandType",(char *) "winid", NULL
18852 };
18853
18854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18855 if (obj0) {
18856 ecode1 = SWIG_AsVal_int(obj0, &val1);
18857 if (!SWIG_IsOK(ecode1)) {
18858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18859 }
18860 arg1 = static_cast< wxEventType >(val1);
18861 }
18862 if (obj1) {
18863 ecode2 = SWIG_AsVal_int(obj1, &val2);
18864 if (!SWIG_IsOK(ecode2)) {
18865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18866 }
18867 arg2 = static_cast< int >(val2);
18868 }
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18883 PyObject *resultobj = 0;
18884 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18885 int result;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 PyObject *swig_obj[1] ;
18889
18890 if (!args) SWIG_fail;
18891 swig_obj[0] = args;
18892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18893 if (!SWIG_IsOK(res1)) {
18894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18895 }
18896 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_From_int(static_cast< int >(result));
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = 0;
18912 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18913 wxString *arg2 = 0 ;
18914 void *argp1 = 0 ;
18915 int res1 = 0 ;
18916 bool temp2 = false ;
18917 PyObject * obj0 = 0 ;
18918 PyObject * obj1 = 0 ;
18919 char * kwnames[] = {
18920 (char *) "self",(char *) "s", NULL
18921 };
18922
18923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18925 if (!SWIG_IsOK(res1)) {
18926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18927 }
18928 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18929 {
18930 arg2 = wxString_in_helper(obj1);
18931 if (arg2 == NULL) SWIG_fail;
18932 temp2 = true;
18933 }
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 (arg1)->SetString((wxString const &)*arg2);
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 resultobj = SWIG_Py_Void();
18941 {
18942 if (temp2)
18943 delete arg2;
18944 }
18945 return resultobj;
18946 fail:
18947 {
18948 if (temp2)
18949 delete arg2;
18950 }
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18956 PyObject *resultobj = 0;
18957 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18958 wxString result;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 PyObject *swig_obj[1] ;
18962
18963 if (!args) SWIG_fail;
18964 swig_obj[0] = args;
18965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18966 if (!SWIG_IsOK(res1)) {
18967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18968 }
18969 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18970 {
18971 PyThreadState* __tstate = wxPyBeginAllowThreads();
18972 result = ((wxCommandEvent const *)arg1)->GetString();
18973 wxPyEndAllowThreads(__tstate);
18974 if (PyErr_Occurred()) SWIG_fail;
18975 }
18976 {
18977 #if wxUSE_UNICODE
18978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18979 #else
18980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18981 #endif
18982 }
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18990 PyObject *resultobj = 0;
18991 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18992 bool result;
18993 void *argp1 = 0 ;
18994 int res1 = 0 ;
18995 PyObject *swig_obj[1] ;
18996
18997 if (!args) SWIG_fail;
18998 swig_obj[0] = args;
18999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19002 }
19003 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19007 wxPyEndAllowThreads(__tstate);
19008 if (PyErr_Occurred()) SWIG_fail;
19009 }
19010 {
19011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19012 }
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19020 PyObject *resultobj = 0;
19021 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19022 bool result;
19023 void *argp1 = 0 ;
19024 int res1 = 0 ;
19025 PyObject *swig_obj[1] ;
19026
19027 if (!args) SWIG_fail;
19028 swig_obj[0] = args;
19029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19030 if (!SWIG_IsOK(res1)) {
19031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19032 }
19033 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19034 {
19035 PyThreadState* __tstate = wxPyBeginAllowThreads();
19036 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19037 wxPyEndAllowThreads(__tstate);
19038 if (PyErr_Occurred()) SWIG_fail;
19039 }
19040 {
19041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19042 }
19043 return resultobj;
19044 fail:
19045 return NULL;
19046 }
19047
19048
19049 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19050 PyObject *resultobj = 0;
19051 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19052 long arg2 ;
19053 void *argp1 = 0 ;
19054 int res1 = 0 ;
19055 long val2 ;
19056 int ecode2 = 0 ;
19057 PyObject * obj0 = 0 ;
19058 PyObject * obj1 = 0 ;
19059 char * kwnames[] = {
19060 (char *) "self",(char *) "extraLong", NULL
19061 };
19062
19063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19065 if (!SWIG_IsOK(res1)) {
19066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19067 }
19068 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19069 ecode2 = SWIG_AsVal_long(obj1, &val2);
19070 if (!SWIG_IsOK(ecode2)) {
19071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19072 }
19073 arg2 = static_cast< long >(val2);
19074 {
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 (arg1)->SetExtraLong(arg2);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 resultobj = SWIG_Py_Void();
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19088 PyObject *resultobj = 0;
19089 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19090 long result;
19091 void *argp1 = 0 ;
19092 int res1 = 0 ;
19093 PyObject *swig_obj[1] ;
19094
19095 if (!args) SWIG_fail;
19096 swig_obj[0] = args;
19097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19098 if (!SWIG_IsOK(res1)) {
19099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19100 }
19101 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19102 {
19103 PyThreadState* __tstate = wxPyBeginAllowThreads();
19104 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 resultobj = SWIG_From_long(static_cast< long >(result));
19109 return resultobj;
19110 fail:
19111 return NULL;
19112 }
19113
19114
19115 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19116 PyObject *resultobj = 0;
19117 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19118 int arg2 ;
19119 void *argp1 = 0 ;
19120 int res1 = 0 ;
19121 int val2 ;
19122 int ecode2 = 0 ;
19123 PyObject * obj0 = 0 ;
19124 PyObject * obj1 = 0 ;
19125 char * kwnames[] = {
19126 (char *) "self",(char *) "i", NULL
19127 };
19128
19129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19131 if (!SWIG_IsOK(res1)) {
19132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19133 }
19134 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19135 ecode2 = SWIG_AsVal_int(obj1, &val2);
19136 if (!SWIG_IsOK(ecode2)) {
19137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19138 }
19139 arg2 = static_cast< int >(val2);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 (arg1)->SetInt(arg2);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = SWIG_Py_Void();
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19154 PyObject *resultobj = 0;
19155 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19156 int result;
19157 void *argp1 = 0 ;
19158 int res1 = 0 ;
19159 PyObject *swig_obj[1] ;
19160
19161 if (!args) SWIG_fail;
19162 swig_obj[0] = args;
19163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19166 }
19167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = SWIG_From_int(static_cast< int >(result));
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19182 PyObject *resultobj = 0;
19183 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19184 PyObject *result = 0 ;
19185 void *argp1 = 0 ;
19186 int res1 = 0 ;
19187 PyObject *swig_obj[1] ;
19188
19189 if (!args) SWIG_fail;
19190 swig_obj[0] = args;
19191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19192 if (!SWIG_IsOK(res1)) {
19193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19194 }
19195 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19196 {
19197 PyThreadState* __tstate = wxPyBeginAllowThreads();
19198 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = result;
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj = 0;
19211 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19212 PyObject *arg2 = (PyObject *) 0 ;
19213 void *argp1 = 0 ;
19214 int res1 = 0 ;
19215 PyObject * obj0 = 0 ;
19216 PyObject * obj1 = 0 ;
19217 char * kwnames[] = {
19218 (char *) "self",(char *) "clientData", NULL
19219 };
19220
19221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19223 if (!SWIG_IsOK(res1)) {
19224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19225 }
19226 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19227 arg2 = obj1;
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 wxCommandEvent_SetClientData(arg1,arg2);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_Py_Void();
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19242 PyObject *resultobj = 0;
19243 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19244 wxEvent *result = 0 ;
19245 void *argp1 = 0 ;
19246 int res1 = 0 ;
19247 PyObject *swig_obj[1] ;
19248
19249 if (!args) SWIG_fail;
19250 swig_obj[0] = args;
19251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19252 if (!SWIG_IsOK(res1)) {
19253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19254 }
19255 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19270 PyObject *obj;
19271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19272 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19273 return SWIG_Py_Void();
19274 }
19275
19276 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19277 return SWIG_Python_InitShadowInstance(args);
19278 }
19279
19280 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19281 PyObject *resultobj = 0;
19282 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19283 int arg2 = (int) 0 ;
19284 wxNotifyEvent *result = 0 ;
19285 int val1 ;
19286 int ecode1 = 0 ;
19287 int val2 ;
19288 int ecode2 = 0 ;
19289 PyObject * obj0 = 0 ;
19290 PyObject * obj1 = 0 ;
19291 char * kwnames[] = {
19292 (char *) "commandType",(char *) "winid", NULL
19293 };
19294
19295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19296 if (obj0) {
19297 ecode1 = SWIG_AsVal_int(obj0, &val1);
19298 if (!SWIG_IsOK(ecode1)) {
19299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19300 }
19301 arg1 = static_cast< wxEventType >(val1);
19302 }
19303 if (obj1) {
19304 ecode2 = SWIG_AsVal_int(obj1, &val2);
19305 if (!SWIG_IsOK(ecode2)) {
19306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19307 }
19308 arg2 = static_cast< int >(val2);
19309 }
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19324 PyObject *resultobj = 0;
19325 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19326 void *argp1 = 0 ;
19327 int res1 = 0 ;
19328 PyObject *swig_obj[1] ;
19329
19330 if (!args) SWIG_fail;
19331 swig_obj[0] = args;
19332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19333 if (!SWIG_IsOK(res1)) {
19334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19335 }
19336 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 (arg1)->Veto();
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_Py_Void();
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19353 void *argp1 = 0 ;
19354 int res1 = 0 ;
19355 PyObject *swig_obj[1] ;
19356
19357 if (!args) SWIG_fail;
19358 swig_obj[0] = args;
19359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19360 if (!SWIG_IsOK(res1)) {
19361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19362 }
19363 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 (arg1)->Allow();
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 resultobj = SWIG_Py_Void();
19371 return resultobj;
19372 fail:
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19378 PyObject *resultobj = 0;
19379 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19380 bool result;
19381 void *argp1 = 0 ;
19382 int res1 = 0 ;
19383 PyObject *swig_obj[1] ;
19384
19385 if (!args) SWIG_fail;
19386 swig_obj[0] = args;
19387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19388 if (!SWIG_IsOK(res1)) {
19389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19390 }
19391 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19392 {
19393 PyThreadState* __tstate = wxPyBeginAllowThreads();
19394 result = (bool)(arg1)->IsAllowed();
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 {
19399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19400 }
19401 return resultobj;
19402 fail:
19403 return NULL;
19404 }
19405
19406
19407 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19408 PyObject *obj;
19409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19410 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19411 return SWIG_Py_Void();
19412 }
19413
19414 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19415 return SWIG_Python_InitShadowInstance(args);
19416 }
19417
19418 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19421 int arg2 = (int) 0 ;
19422 int arg3 = (int) 0 ;
19423 int arg4 = (int) 0 ;
19424 wxScrollEvent *result = 0 ;
19425 int val1 ;
19426 int ecode1 = 0 ;
19427 int val2 ;
19428 int ecode2 = 0 ;
19429 int val3 ;
19430 int ecode3 = 0 ;
19431 int val4 ;
19432 int ecode4 = 0 ;
19433 PyObject * obj0 = 0 ;
19434 PyObject * obj1 = 0 ;
19435 PyObject * obj2 = 0 ;
19436 PyObject * obj3 = 0 ;
19437 char * kwnames[] = {
19438 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19439 };
19440
19441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19442 if (obj0) {
19443 ecode1 = SWIG_AsVal_int(obj0, &val1);
19444 if (!SWIG_IsOK(ecode1)) {
19445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19446 }
19447 arg1 = static_cast< wxEventType >(val1);
19448 }
19449 if (obj1) {
19450 ecode2 = SWIG_AsVal_int(obj1, &val2);
19451 if (!SWIG_IsOK(ecode2)) {
19452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19453 }
19454 arg2 = static_cast< int >(val2);
19455 }
19456 if (obj2) {
19457 ecode3 = SWIG_AsVal_int(obj2, &val3);
19458 if (!SWIG_IsOK(ecode3)) {
19459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19460 }
19461 arg3 = static_cast< int >(val3);
19462 }
19463 if (obj3) {
19464 ecode4 = SWIG_AsVal_int(obj3, &val4);
19465 if (!SWIG_IsOK(ecode4)) {
19466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19467 }
19468 arg4 = static_cast< int >(val4);
19469 }
19470 {
19471 PyThreadState* __tstate = wxPyBeginAllowThreads();
19472 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19473 wxPyEndAllowThreads(__tstate);
19474 if (PyErr_Occurred()) SWIG_fail;
19475 }
19476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19484 PyObject *resultobj = 0;
19485 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19486 int result;
19487 void *argp1 = 0 ;
19488 int res1 = 0 ;
19489 PyObject *swig_obj[1] ;
19490
19491 if (!args) SWIG_fail;
19492 swig_obj[0] = args;
19493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19494 if (!SWIG_IsOK(res1)) {
19495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19496 }
19497 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 resultobj = SWIG_From_int(static_cast< int >(result));
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19512 PyObject *resultobj = 0;
19513 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19514 int result;
19515 void *argp1 = 0 ;
19516 int res1 = 0 ;
19517 PyObject *swig_obj[1] ;
19518
19519 if (!args) SWIG_fail;
19520 swig_obj[0] = args;
19521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19522 if (!SWIG_IsOK(res1)) {
19523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19524 }
19525 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19526 {
19527 PyThreadState* __tstate = wxPyBeginAllowThreads();
19528 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 resultobj = SWIG_From_int(static_cast< int >(result));
19533 return resultobj;
19534 fail:
19535 return NULL;
19536 }
19537
19538
19539 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19540 PyObject *resultobj = 0;
19541 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19542 int arg2 ;
19543 void *argp1 = 0 ;
19544 int res1 = 0 ;
19545 int val2 ;
19546 int ecode2 = 0 ;
19547 PyObject * obj0 = 0 ;
19548 PyObject * obj1 = 0 ;
19549 char * kwnames[] = {
19550 (char *) "self",(char *) "orient", NULL
19551 };
19552
19553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19555 if (!SWIG_IsOK(res1)) {
19556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19557 }
19558 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19559 ecode2 = SWIG_AsVal_int(obj1, &val2);
19560 if (!SWIG_IsOK(ecode2)) {
19561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19562 }
19563 arg2 = static_cast< int >(val2);
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 (arg1)->SetOrientation(arg2);
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 resultobj = SWIG_Py_Void();
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj = 0;
19579 wxScrollEvent *arg1 = (wxScrollEvent *) 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 *) "pos", NULL
19589 };
19590
19591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19593 if (!SWIG_IsOK(res1)) {
19594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19595 }
19596 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19597 ecode2 = SWIG_AsVal_int(obj1, &val2);
19598 if (!SWIG_IsOK(ecode2)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19600 }
19601 arg2 = static_cast< int >(val2);
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 (arg1)->SetPosition(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 *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19616 PyObject *obj;
19617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19618 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19619 return SWIG_Py_Void();
19620 }
19621
19622 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 return SWIG_Python_InitShadowInstance(args);
19624 }
19625
19626 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19629 int arg2 = (int) 0 ;
19630 int arg3 = (int) 0 ;
19631 wxScrollWinEvent *result = 0 ;
19632 int val1 ;
19633 int ecode1 = 0 ;
19634 int val2 ;
19635 int ecode2 = 0 ;
19636 int val3 ;
19637 int ecode3 = 0 ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 PyObject * obj2 = 0 ;
19641 char * kwnames[] = {
19642 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19643 };
19644
19645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19646 if (obj0) {
19647 ecode1 = SWIG_AsVal_int(obj0, &val1);
19648 if (!SWIG_IsOK(ecode1)) {
19649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19650 }
19651 arg1 = static_cast< wxEventType >(val1);
19652 }
19653 if (obj1) {
19654 ecode2 = SWIG_AsVal_int(obj1, &val2);
19655 if (!SWIG_IsOK(ecode2)) {
19656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19657 }
19658 arg2 = static_cast< int >(val2);
19659 }
19660 if (obj2) {
19661 ecode3 = SWIG_AsVal_int(obj2, &val3);
19662 if (!SWIG_IsOK(ecode3)) {
19663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19664 }
19665 arg3 = static_cast< int >(val3);
19666 }
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19681 PyObject *resultobj = 0;
19682 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19683 int result;
19684 void *argp1 = 0 ;
19685 int res1 = 0 ;
19686 PyObject *swig_obj[1] ;
19687
19688 if (!args) SWIG_fail;
19689 swig_obj[0] = args;
19690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19691 if (!SWIG_IsOK(res1)) {
19692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19693 }
19694 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19698 wxPyEndAllowThreads(__tstate);
19699 if (PyErr_Occurred()) SWIG_fail;
19700 }
19701 resultobj = SWIG_From_int(static_cast< int >(result));
19702 return resultobj;
19703 fail:
19704 return NULL;
19705 }
19706
19707
19708 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19709 PyObject *resultobj = 0;
19710 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19711 int result;
19712 void *argp1 = 0 ;
19713 int res1 = 0 ;
19714 PyObject *swig_obj[1] ;
19715
19716 if (!args) SWIG_fail;
19717 swig_obj[0] = args;
19718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19721 }
19722 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19723 {
19724 PyThreadState* __tstate = wxPyBeginAllowThreads();
19725 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19726 wxPyEndAllowThreads(__tstate);
19727 if (PyErr_Occurred()) SWIG_fail;
19728 }
19729 resultobj = SWIG_From_int(static_cast< int >(result));
19730 return resultobj;
19731 fail:
19732 return NULL;
19733 }
19734
19735
19736 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj = 0;
19738 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19739 int arg2 ;
19740 void *argp1 = 0 ;
19741 int res1 = 0 ;
19742 int val2 ;
19743 int ecode2 = 0 ;
19744 PyObject * obj0 = 0 ;
19745 PyObject * obj1 = 0 ;
19746 char * kwnames[] = {
19747 (char *) "self",(char *) "orient", NULL
19748 };
19749
19750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19754 }
19755 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19756 ecode2 = SWIG_AsVal_int(obj1, &val2);
19757 if (!SWIG_IsOK(ecode2)) {
19758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19759 }
19760 arg2 = static_cast< int >(val2);
19761 {
19762 PyThreadState* __tstate = wxPyBeginAllowThreads();
19763 (arg1)->SetOrientation(arg2);
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 resultobj = SWIG_Py_Void();
19768 return resultobj;
19769 fail:
19770 return NULL;
19771 }
19772
19773
19774 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj = 0;
19776 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19777 int arg2 ;
19778 void *argp1 = 0 ;
19779 int res1 = 0 ;
19780 int val2 ;
19781 int ecode2 = 0 ;
19782 PyObject * obj0 = 0 ;
19783 PyObject * obj1 = 0 ;
19784 char * kwnames[] = {
19785 (char *) "self",(char *) "pos", NULL
19786 };
19787
19788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19792 }
19793 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19794 ecode2 = SWIG_AsVal_int(obj1, &val2);
19795 if (!SWIG_IsOK(ecode2)) {
19796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19797 }
19798 arg2 = static_cast< int >(val2);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 (arg1)->SetPosition(arg2);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 resultobj = SWIG_Py_Void();
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19813 PyObject *obj;
19814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19815 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19816 return SWIG_Py_Void();
19817 }
19818
19819 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19820 return SWIG_Python_InitShadowInstance(args);
19821 }
19822
19823 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19826 wxMouseEvent *result = 0 ;
19827 int val1 ;
19828 int ecode1 = 0 ;
19829 PyObject * obj0 = 0 ;
19830 char * kwnames[] = {
19831 (char *) "mouseType", NULL
19832 };
19833
19834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19835 if (obj0) {
19836 ecode1 = SWIG_AsVal_int(obj0, &val1);
19837 if (!SWIG_IsOK(ecode1)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19839 }
19840 arg1 = static_cast< wxEventType >(val1);
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19858 PyObject *resultobj = 0;
19859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19860 bool result;
19861 void *argp1 = 0 ;
19862 int res1 = 0 ;
19863 PyObject *swig_obj[1] ;
19864
19865 if (!args) SWIG_fail;
19866 swig_obj[0] = args;
19867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19868 if (!SWIG_IsOK(res1)) {
19869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19870 }
19871 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 {
19879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19880 }
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj = 0;
19889 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19890 int arg2 = (int) wxMOUSE_BTN_ANY ;
19891 bool result;
19892 void *argp1 = 0 ;
19893 int res1 = 0 ;
19894 int val2 ;
19895 int ecode2 = 0 ;
19896 PyObject * obj0 = 0 ;
19897 PyObject * obj1 = 0 ;
19898 char * kwnames[] = {
19899 (char *) "self",(char *) "but", NULL
19900 };
19901
19902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19904 if (!SWIG_IsOK(res1)) {
19905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19906 }
19907 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19908 if (obj1) {
19909 ecode2 = SWIG_AsVal_int(obj1, &val2);
19910 if (!SWIG_IsOK(ecode2)) {
19911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19912 }
19913 arg2 = static_cast< int >(val2);
19914 }
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19918 wxPyEndAllowThreads(__tstate);
19919 if (PyErr_Occurred()) SWIG_fail;
19920 }
19921 {
19922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19923 }
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj = 0;
19932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19933 int arg2 = (int) wxMOUSE_BTN_ANY ;
19934 bool result;
19935 void *argp1 = 0 ;
19936 int res1 = 0 ;
19937 int val2 ;
19938 int ecode2 = 0 ;
19939 PyObject * obj0 = 0 ;
19940 PyObject * obj1 = 0 ;
19941 char * kwnames[] = {
19942 (char *) "self",(char *) "but", NULL
19943 };
19944
19945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19947 if (!SWIG_IsOK(res1)) {
19948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19949 }
19950 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19951 if (obj1) {
19952 ecode2 = SWIG_AsVal_int(obj1, &val2);
19953 if (!SWIG_IsOK(ecode2)) {
19954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19955 }
19956 arg2 = static_cast< int >(val2);
19957 }
19958 {
19959 PyThreadState* __tstate = wxPyBeginAllowThreads();
19960 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 {
19965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19966 }
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj = 0;
19975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19976 int arg2 = (int) wxMOUSE_BTN_ANY ;
19977 bool result;
19978 void *argp1 = 0 ;
19979 int res1 = 0 ;
19980 int val2 ;
19981 int ecode2 = 0 ;
19982 PyObject * obj0 = 0 ;
19983 PyObject * obj1 = 0 ;
19984 char * kwnames[] = {
19985 (char *) "self",(char *) "but", NULL
19986 };
19987
19988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19990 if (!SWIG_IsOK(res1)) {
19991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19992 }
19993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19994 if (obj1) {
19995 ecode2 = SWIG_AsVal_int(obj1, &val2);
19996 if (!SWIG_IsOK(ecode2)) {
19997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19998 }
19999 arg2 = static_cast< int >(val2);
20000 }
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20004 wxPyEndAllowThreads(__tstate);
20005 if (PyErr_Occurred()) SWIG_fail;
20006 }
20007 {
20008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20009 }
20010 return resultobj;
20011 fail:
20012 return NULL;
20013 }
20014
20015
20016 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20017 PyObject *resultobj = 0;
20018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20019 int arg2 ;
20020 bool result;
20021 void *argp1 = 0 ;
20022 int res1 = 0 ;
20023 int val2 ;
20024 int ecode2 = 0 ;
20025 PyObject * obj0 = 0 ;
20026 PyObject * obj1 = 0 ;
20027 char * kwnames[] = {
20028 (char *) "self",(char *) "button", NULL
20029 };
20030
20031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20033 if (!SWIG_IsOK(res1)) {
20034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20035 }
20036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20037 ecode2 = SWIG_AsVal_int(obj1, &val2);
20038 if (!SWIG_IsOK(ecode2)) {
20039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20040 }
20041 arg2 = static_cast< int >(val2);
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
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_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj = 0;
20059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20060 int arg2 ;
20061 bool result;
20062 void *argp1 = 0 ;
20063 int res1 = 0 ;
20064 int val2 ;
20065 int ecode2 = 0 ;
20066 PyObject * obj0 = 0 ;
20067 PyObject * obj1 = 0 ;
20068 char * kwnames[] = {
20069 (char *) "self",(char *) "but", NULL
20070 };
20071
20072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20074 if (!SWIG_IsOK(res1)) {
20075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20076 }
20077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20078 ecode2 = SWIG_AsVal_int(obj1, &val2);
20079 if (!SWIG_IsOK(ecode2)) {
20080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20081 }
20082 arg2 = static_cast< int >(val2);
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20086 wxPyEndAllowThreads(__tstate);
20087 if (PyErr_Occurred()) SWIG_fail;
20088 }
20089 {
20090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20091 }
20092 return resultobj;
20093 fail:
20094 return NULL;
20095 }
20096
20097
20098 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20099 PyObject *resultobj = 0;
20100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20101 int result;
20102 void *argp1 = 0 ;
20103 int res1 = 0 ;
20104 PyObject *swig_obj[1] ;
20105
20106 if (!args) SWIG_fail;
20107 swig_obj[0] = args;
20108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20109 if (!SWIG_IsOK(res1)) {
20110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20111 }
20112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 resultobj = SWIG_From_int(static_cast< int >(result));
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20127 PyObject *resultobj = 0;
20128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20129 bool result;
20130 void *argp1 = 0 ;
20131 int res1 = 0 ;
20132 PyObject *swig_obj[1] ;
20133
20134 if (!args) SWIG_fail;
20135 swig_obj[0] = args;
20136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20137 if (!SWIG_IsOK(res1)) {
20138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20139 }
20140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20141 {
20142 PyThreadState* __tstate = wxPyBeginAllowThreads();
20143 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20144 wxPyEndAllowThreads(__tstate);
20145 if (PyErr_Occurred()) SWIG_fail;
20146 }
20147 {
20148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20149 }
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20157 PyObject *resultobj = 0;
20158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20159 bool result;
20160 void *argp1 = 0 ;
20161 int res1 = 0 ;
20162 PyObject *swig_obj[1] ;
20163
20164 if (!args) SWIG_fail;
20165 swig_obj[0] = args;
20166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20167 if (!SWIG_IsOK(res1)) {
20168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20169 }
20170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 {
20178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20179 }
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20189 bool result;
20190 void *argp1 = 0 ;
20191 int res1 = 0 ;
20192 PyObject *swig_obj[1] ;
20193
20194 if (!args) SWIG_fail;
20195 swig_obj[0] = args;
20196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20197 if (!SWIG_IsOK(res1)) {
20198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20199 }
20200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20201 {
20202 PyThreadState* __tstate = wxPyBeginAllowThreads();
20203 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 {
20208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20209 }
20210 return resultobj;
20211 fail:
20212 return NULL;
20213 }
20214
20215
20216 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *resultobj = 0;
20218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20219 bool result;
20220 void *argp1 = 0 ;
20221 int res1 = 0 ;
20222 PyObject *swig_obj[1] ;
20223
20224 if (!args) SWIG_fail;
20225 swig_obj[0] = args;
20226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20227 if (!SWIG_IsOK(res1)) {
20228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20229 }
20230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 PyObject *resultobj = 0;
20248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20249 bool result;
20250 void *argp1 = 0 ;
20251 int res1 = 0 ;
20252 PyObject *swig_obj[1] ;
20253
20254 if (!args) SWIG_fail;
20255 swig_obj[0] = args;
20256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20257 if (!SWIG_IsOK(res1)) {
20258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20259 }
20260 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 {
20268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20269 }
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *resultobj = 0;
20278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20279 bool result;
20280 void *argp1 = 0 ;
20281 int res1 = 0 ;
20282 PyObject *swig_obj[1] ;
20283
20284 if (!args) SWIG_fail;
20285 swig_obj[0] = args;
20286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20287 if (!SWIG_IsOK(res1)) {
20288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20289 }
20290 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 {
20298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20299 }
20300 return resultobj;
20301 fail:
20302 return NULL;
20303 }
20304
20305
20306 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20307 PyObject *resultobj = 0;
20308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20309 bool result;
20310 void *argp1 = 0 ;
20311 int res1 = 0 ;
20312 PyObject *swig_obj[1] ;
20313
20314 if (!args) SWIG_fail;
20315 swig_obj[0] = args;
20316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20317 if (!SWIG_IsOK(res1)) {
20318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20319 }
20320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 {
20328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20329 }
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20337 PyObject *resultobj = 0;
20338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20339 bool result;
20340 void *argp1 = 0 ;
20341 int res1 = 0 ;
20342 PyObject *swig_obj[1] ;
20343
20344 if (!args) SWIG_fail;
20345 swig_obj[0] = args;
20346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20347 if (!SWIG_IsOK(res1)) {
20348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20349 }
20350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20359 }
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20367 PyObject *resultobj = 0;
20368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20369 bool result;
20370 void *argp1 = 0 ;
20371 int res1 = 0 ;
20372 PyObject *swig_obj[1] ;
20373
20374 if (!args) SWIG_fail;
20375 swig_obj[0] = args;
20376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20377 if (!SWIG_IsOK(res1)) {
20378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20379 }
20380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20389 }
20390 return resultobj;
20391 fail:
20392 return NULL;
20393 }
20394
20395
20396 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20397 PyObject *resultobj = 0;
20398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20399 bool result;
20400 void *argp1 = 0 ;
20401 int res1 = 0 ;
20402 PyObject *swig_obj[1] ;
20403
20404 if (!args) SWIG_fail;
20405 swig_obj[0] = args;
20406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20407 if (!SWIG_IsOK(res1)) {
20408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20409 }
20410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20419 }
20420 return resultobj;
20421 fail:
20422 return NULL;
20423 }
20424
20425
20426 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20427 PyObject *resultobj = 0;
20428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20429 bool result;
20430 void *argp1 = 0 ;
20431 int res1 = 0 ;
20432 PyObject *swig_obj[1] ;
20433
20434 if (!args) SWIG_fail;
20435 swig_obj[0] = args;
20436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20437 if (!SWIG_IsOK(res1)) {
20438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20439 }
20440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20449 }
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20459 bool result;
20460 void *argp1 = 0 ;
20461 int res1 = 0 ;
20462 PyObject *swig_obj[1] ;
20463
20464 if (!args) SWIG_fail;
20465 swig_obj[0] = args;
20466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20467 if (!SWIG_IsOK(res1)) {
20468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20469 }
20470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20479 }
20480 return resultobj;
20481 fail:
20482 return NULL;
20483 }
20484
20485
20486 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487 PyObject *resultobj = 0;
20488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20489 bool result;
20490 void *argp1 = 0 ;
20491 int res1 = 0 ;
20492 PyObject *swig_obj[1] ;
20493
20494 if (!args) SWIG_fail;
20495 swig_obj[0] = args;
20496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20497 if (!SWIG_IsOK(res1)) {
20498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20499 }
20500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 {
20508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20509 }
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20517 PyObject *resultobj = 0;
20518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20519 bool result;
20520 void *argp1 = 0 ;
20521 int res1 = 0 ;
20522 PyObject *swig_obj[1] ;
20523
20524 if (!args) SWIG_fail;
20525 swig_obj[0] = args;
20526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20527 if (!SWIG_IsOK(res1)) {
20528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20529 }
20530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *resultobj = 0;
20548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20549 bool result;
20550 void *argp1 = 0 ;
20551 int res1 = 0 ;
20552 PyObject *swig_obj[1] ;
20553
20554 if (!args) SWIG_fail;
20555 swig_obj[0] = args;
20556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20559 }
20560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)(arg1)->LeftIsDown();
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20569 }
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20577 PyObject *resultobj = 0;
20578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20579 bool result;
20580 void *argp1 = 0 ;
20581 int res1 = 0 ;
20582 PyObject *swig_obj[1] ;
20583
20584 if (!args) SWIG_fail;
20585 swig_obj[0] = args;
20586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20587 if (!SWIG_IsOK(res1)) {
20588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20589 }
20590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 result = (bool)(arg1)->MiddleIsDown();
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 {
20598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20607 PyObject *resultobj = 0;
20608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20609 bool result;
20610 void *argp1 = 0 ;
20611 int res1 = 0 ;
20612 PyObject *swig_obj[1] ;
20613
20614 if (!args) SWIG_fail;
20615 swig_obj[0] = args;
20616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20617 if (!SWIG_IsOK(res1)) {
20618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20619 }
20620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20621 {
20622 PyThreadState* __tstate = wxPyBeginAllowThreads();
20623 result = (bool)(arg1)->RightIsDown();
20624 wxPyEndAllowThreads(__tstate);
20625 if (PyErr_Occurred()) SWIG_fail;
20626 }
20627 {
20628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20629 }
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20637 PyObject *resultobj = 0;
20638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20639 bool result;
20640 void *argp1 = 0 ;
20641 int res1 = 0 ;
20642 PyObject *swig_obj[1] ;
20643
20644 if (!args) SWIG_fail;
20645 swig_obj[0] = args;
20646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20649 }
20650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20667 PyObject *resultobj = 0;
20668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20669 bool result;
20670 void *argp1 = 0 ;
20671 int res1 = 0 ;
20672 PyObject *swig_obj[1] ;
20673
20674 if (!args) SWIG_fail;
20675 swig_obj[0] = args;
20676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20677 if (!SWIG_IsOK(res1)) {
20678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20679 }
20680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20684 wxPyEndAllowThreads(__tstate);
20685 if (PyErr_Occurred()) SWIG_fail;
20686 }
20687 {
20688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20689 }
20690 return resultobj;
20691 fail:
20692 return NULL;
20693 }
20694
20695
20696 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20697 PyObject *resultobj = 0;
20698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20699 bool result;
20700 void *argp1 = 0 ;
20701 int res1 = 0 ;
20702 PyObject *swig_obj[1] ;
20703
20704 if (!args) SWIG_fail;
20705 swig_obj[0] = args;
20706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20707 if (!SWIG_IsOK(res1)) {
20708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20709 }
20710 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20727 PyObject *resultobj = 0;
20728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20729 bool result;
20730 void *argp1 = 0 ;
20731 int res1 = 0 ;
20732 PyObject *swig_obj[1] ;
20733
20734 if (!args) SWIG_fail;
20735 swig_obj[0] = args;
20736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20739 }
20740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 {
20748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20749 }
20750 return resultobj;
20751 fail:
20752 return NULL;
20753 }
20754
20755
20756 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20757 PyObject *resultobj = 0;
20758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20759 wxPoint result;
20760 void *argp1 = 0 ;
20761 int res1 = 0 ;
20762 PyObject *swig_obj[1] ;
20763
20764 if (!args) SWIG_fail;
20765 swig_obj[0] = args;
20766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20767 if (!SWIG_IsOK(res1)) {
20768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20769 }
20770 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (arg1)->GetPosition();
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20778 return resultobj;
20779 fail:
20780 return NULL;
20781 }
20782
20783
20784 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20785 PyObject *resultobj = 0;
20786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20787 long *arg2 = (long *) 0 ;
20788 long *arg3 = (long *) 0 ;
20789 void *argp1 = 0 ;
20790 int res1 = 0 ;
20791 long temp2 ;
20792 int res2 = SWIG_TMPOBJ ;
20793 long temp3 ;
20794 int res3 = SWIG_TMPOBJ ;
20795 PyObject *swig_obj[1] ;
20796
20797 arg2 = &temp2;
20798 arg3 = &temp3;
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 (arg1)->GetPosition(arg2,arg3);
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 resultobj = SWIG_Py_Void();
20813 if (SWIG_IsTmpObj(res2)) {
20814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20815 } else {
20816 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20818 }
20819 if (SWIG_IsTmpObj(res3)) {
20820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20821 } else {
20822 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20824 }
20825 return resultobj;
20826 fail:
20827 return NULL;
20828 }
20829
20830
20831 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20832 PyObject *resultobj = 0;
20833 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20834 wxDC *arg2 = 0 ;
20835 wxPoint result;
20836 void *argp1 = 0 ;
20837 int res1 = 0 ;
20838 void *argp2 = 0 ;
20839 int res2 = 0 ;
20840 PyObject * obj0 = 0 ;
20841 PyObject * obj1 = 0 ;
20842 char * kwnames[] = {
20843 (char *) "self",(char *) "dc", NULL
20844 };
20845
20846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20848 if (!SWIG_IsOK(res1)) {
20849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20850 }
20851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20853 if (!SWIG_IsOK(res2)) {
20854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20855 }
20856 if (!argp2) {
20857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20858 }
20859 arg2 = reinterpret_cast< wxDC * >(argp2);
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20874 PyObject *resultobj = 0;
20875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20876 int result;
20877 void *argp1 = 0 ;
20878 int res1 = 0 ;
20879 PyObject *swig_obj[1] ;
20880
20881 if (!args) SWIG_fail;
20882 swig_obj[0] = args;
20883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20884 if (!SWIG_IsOK(res1)) {
20885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20886 }
20887 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (int)((wxMouseEvent const *)arg1)->GetX();
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = SWIG_From_int(static_cast< int >(result));
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20902 PyObject *resultobj = 0;
20903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20904 int result;
20905 void *argp1 = 0 ;
20906 int res1 = 0 ;
20907 PyObject *swig_obj[1] ;
20908
20909 if (!args) SWIG_fail;
20910 swig_obj[0] = args;
20911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20914 }
20915 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (int)((wxMouseEvent const *)arg1)->GetY();
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_From_int(static_cast< int >(result));
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *resultobj = 0;
20931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20932 int result;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20942 }
20943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_From_int(static_cast< int >(result));
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20958 PyObject *resultobj = 0;
20959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20960 int result;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 PyObject *swig_obj[1] ;
20964
20965 if (!args) SWIG_fail;
20966 swig_obj[0] = args;
20967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20970 }
20971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 resultobj = SWIG_From_int(static_cast< int >(result));
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20986 PyObject *resultobj = 0;
20987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20988 int result;
20989 void *argp1 = 0 ;
20990 int res1 = 0 ;
20991 PyObject *swig_obj[1] ;
20992
20993 if (!args) SWIG_fail;
20994 swig_obj[0] = args;
20995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20996 if (!SWIG_IsOK(res1)) {
20997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20998 }
20999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_From_int(static_cast< int >(result));
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21016 bool result;
21017 void *argp1 = 0 ;
21018 int res1 = 0 ;
21019 PyObject *swig_obj[1] ;
21020
21021 if (!args) SWIG_fail;
21022 swig_obj[0] = args;
21023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21026 }
21027 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 {
21035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21036 }
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 PyObject *resultobj = 0;
21045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21046 int arg2 ;
21047 void *argp1 = 0 ;
21048 int res1 = 0 ;
21049 int val2 ;
21050 int ecode2 = 0 ;
21051 PyObject *swig_obj[2] ;
21052
21053 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21057 }
21058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21059 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21060 if (!SWIG_IsOK(ecode2)) {
21061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21062 }
21063 arg2 = static_cast< int >(val2);
21064 if (arg1) (arg1)->m_x = arg2;
21065
21066 resultobj = SWIG_Py_Void();
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21074 PyObject *resultobj = 0;
21075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21076 int result;
21077 void *argp1 = 0 ;
21078 int res1 = 0 ;
21079 PyObject *swig_obj[1] ;
21080
21081 if (!args) SWIG_fail;
21082 swig_obj[0] = args;
21083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21086 }
21087 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21088 result = (int) ((arg1)->m_x);
21089 resultobj = SWIG_From_int(static_cast< int >(result));
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21097 PyObject *resultobj = 0;
21098 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21099 int arg2 ;
21100 void *argp1 = 0 ;
21101 int res1 = 0 ;
21102 int val2 ;
21103 int ecode2 = 0 ;
21104 PyObject *swig_obj[2] ;
21105
21106 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21108 if (!SWIG_IsOK(res1)) {
21109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21110 }
21111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21112 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21113 if (!SWIG_IsOK(ecode2)) {
21114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21115 }
21116 arg2 = static_cast< int >(val2);
21117 if (arg1) (arg1)->m_y = arg2;
21118
21119 resultobj = SWIG_Py_Void();
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21127 PyObject *resultobj = 0;
21128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21129 int result;
21130 void *argp1 = 0 ;
21131 int res1 = 0 ;
21132 PyObject *swig_obj[1] ;
21133
21134 if (!args) SWIG_fail;
21135 swig_obj[0] = args;
21136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21137 if (!SWIG_IsOK(res1)) {
21138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21139 }
21140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21141 result = (int) ((arg1)->m_y);
21142 resultobj = SWIG_From_int(static_cast< int >(result));
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21150 PyObject *resultobj = 0;
21151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21152 bool arg2 ;
21153 void *argp1 = 0 ;
21154 int res1 = 0 ;
21155 bool val2 ;
21156 int ecode2 = 0 ;
21157 PyObject *swig_obj[2] ;
21158
21159 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21161 if (!SWIG_IsOK(res1)) {
21162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21163 }
21164 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21165 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21166 if (!SWIG_IsOK(ecode2)) {
21167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21168 }
21169 arg2 = static_cast< bool >(val2);
21170 if (arg1) (arg1)->m_leftDown = arg2;
21171
21172 resultobj = SWIG_Py_Void();
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21180 PyObject *resultobj = 0;
21181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21182 bool result;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 PyObject *swig_obj[1] ;
21186
21187 if (!args) SWIG_fail;
21188 swig_obj[0] = args;
21189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21192 }
21193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21194 result = (bool) ((arg1)->m_leftDown);
21195 {
21196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21197 }
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21205 PyObject *resultobj = 0;
21206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21207 bool arg2 ;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 bool val2 ;
21211 int ecode2 = 0 ;
21212 PyObject *swig_obj[2] ;
21213
21214 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21216 if (!SWIG_IsOK(res1)) {
21217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21218 }
21219 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21220 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21221 if (!SWIG_IsOK(ecode2)) {
21222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21223 }
21224 arg2 = static_cast< bool >(val2);
21225 if (arg1) (arg1)->m_middleDown = arg2;
21226
21227 resultobj = SWIG_Py_Void();
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21235 PyObject *resultobj = 0;
21236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21237 bool result;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 PyObject *swig_obj[1] ;
21241
21242 if (!args) SWIG_fail;
21243 swig_obj[0] = args;
21244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21245 if (!SWIG_IsOK(res1)) {
21246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21247 }
21248 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21249 result = (bool) ((arg1)->m_middleDown);
21250 {
21251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21252 }
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21260 PyObject *resultobj = 0;
21261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21262 bool arg2 ;
21263 void *argp1 = 0 ;
21264 int res1 = 0 ;
21265 bool val2 ;
21266 int ecode2 = 0 ;
21267 PyObject *swig_obj[2] ;
21268
21269 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21273 }
21274 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21275 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21276 if (!SWIG_IsOK(ecode2)) {
21277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21278 }
21279 arg2 = static_cast< bool >(val2);
21280 if (arg1) (arg1)->m_rightDown = arg2;
21281
21282 resultobj = SWIG_Py_Void();
21283 return resultobj;
21284 fail:
21285 return NULL;
21286 }
21287
21288
21289 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21290 PyObject *resultobj = 0;
21291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21292 bool result;
21293 void *argp1 = 0 ;
21294 int res1 = 0 ;
21295 PyObject *swig_obj[1] ;
21296
21297 if (!args) SWIG_fail;
21298 swig_obj[0] = args;
21299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21300 if (!SWIG_IsOK(res1)) {
21301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21302 }
21303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21304 result = (bool) ((arg1)->m_rightDown);
21305 {
21306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21307 }
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21317 bool arg2 ;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 bool val2 ;
21321 int ecode2 = 0 ;
21322 PyObject *swig_obj[2] ;
21323
21324 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21326 if (!SWIG_IsOK(res1)) {
21327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21328 }
21329 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21330 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21331 if (!SWIG_IsOK(ecode2)) {
21332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21333 }
21334 arg2 = static_cast< bool >(val2);
21335 if (arg1) (arg1)->m_controlDown = arg2;
21336
21337 resultobj = SWIG_Py_Void();
21338 return resultobj;
21339 fail:
21340 return NULL;
21341 }
21342
21343
21344 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21345 PyObject *resultobj = 0;
21346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21347 bool result;
21348 void *argp1 = 0 ;
21349 int res1 = 0 ;
21350 PyObject *swig_obj[1] ;
21351
21352 if (!args) SWIG_fail;
21353 swig_obj[0] = args;
21354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21355 if (!SWIG_IsOK(res1)) {
21356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21357 }
21358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21359 result = (bool) ((arg1)->m_controlDown);
21360 {
21361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21362 }
21363 return resultobj;
21364 fail:
21365 return NULL;
21366 }
21367
21368
21369 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21370 PyObject *resultobj = 0;
21371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21372 bool arg2 ;
21373 void *argp1 = 0 ;
21374 int res1 = 0 ;
21375 bool val2 ;
21376 int ecode2 = 0 ;
21377 PyObject *swig_obj[2] ;
21378
21379 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21381 if (!SWIG_IsOK(res1)) {
21382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21383 }
21384 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21385 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21386 if (!SWIG_IsOK(ecode2)) {
21387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21388 }
21389 arg2 = static_cast< bool >(val2);
21390 if (arg1) (arg1)->m_shiftDown = arg2;
21391
21392 resultobj = SWIG_Py_Void();
21393 return resultobj;
21394 fail:
21395 return NULL;
21396 }
21397
21398
21399 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21400 PyObject *resultobj = 0;
21401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21402 bool result;
21403 void *argp1 = 0 ;
21404 int res1 = 0 ;
21405 PyObject *swig_obj[1] ;
21406
21407 if (!args) SWIG_fail;
21408 swig_obj[0] = args;
21409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21410 if (!SWIG_IsOK(res1)) {
21411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21412 }
21413 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21414 result = (bool) ((arg1)->m_shiftDown);
21415 {
21416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21417 }
21418 return resultobj;
21419 fail:
21420 return NULL;
21421 }
21422
21423
21424 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21425 PyObject *resultobj = 0;
21426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21427 bool arg2 ;
21428 void *argp1 = 0 ;
21429 int res1 = 0 ;
21430 bool val2 ;
21431 int ecode2 = 0 ;
21432 PyObject *swig_obj[2] ;
21433
21434 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21436 if (!SWIG_IsOK(res1)) {
21437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21438 }
21439 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21440 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21441 if (!SWIG_IsOK(ecode2)) {
21442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21443 }
21444 arg2 = static_cast< bool >(val2);
21445 if (arg1) (arg1)->m_altDown = arg2;
21446
21447 resultobj = SWIG_Py_Void();
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21455 PyObject *resultobj = 0;
21456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21457 bool result;
21458 void *argp1 = 0 ;
21459 int res1 = 0 ;
21460 PyObject *swig_obj[1] ;
21461
21462 if (!args) SWIG_fail;
21463 swig_obj[0] = args;
21464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21465 if (!SWIG_IsOK(res1)) {
21466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21467 }
21468 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21469 result = (bool) ((arg1)->m_altDown);
21470 {
21471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21472 }
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21480 PyObject *resultobj = 0;
21481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21482 bool arg2 ;
21483 void *argp1 = 0 ;
21484 int res1 = 0 ;
21485 bool val2 ;
21486 int ecode2 = 0 ;
21487 PyObject *swig_obj[2] ;
21488
21489 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21491 if (!SWIG_IsOK(res1)) {
21492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21493 }
21494 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21495 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21496 if (!SWIG_IsOK(ecode2)) {
21497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21498 }
21499 arg2 = static_cast< bool >(val2);
21500 if (arg1) (arg1)->m_metaDown = arg2;
21501
21502 resultobj = SWIG_Py_Void();
21503 return resultobj;
21504 fail:
21505 return NULL;
21506 }
21507
21508
21509 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21510 PyObject *resultobj = 0;
21511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21512 bool result;
21513 void *argp1 = 0 ;
21514 int res1 = 0 ;
21515 PyObject *swig_obj[1] ;
21516
21517 if (!args) SWIG_fail;
21518 swig_obj[0] = args;
21519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21520 if (!SWIG_IsOK(res1)) {
21521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21522 }
21523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21524 result = (bool) ((arg1)->m_metaDown);
21525 {
21526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21527 }
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *resultobj = 0;
21536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21537 int arg2 ;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 int val2 ;
21541 int ecode2 = 0 ;
21542 PyObject *swig_obj[2] ;
21543
21544 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21546 if (!SWIG_IsOK(res1)) {
21547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21548 }
21549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21551 if (!SWIG_IsOK(ecode2)) {
21552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21553 }
21554 arg2 = static_cast< int >(val2);
21555 if (arg1) (arg1)->m_wheelRotation = arg2;
21556
21557 resultobj = SWIG_Py_Void();
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21565 PyObject *resultobj = 0;
21566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21567 int result;
21568 void *argp1 = 0 ;
21569 int res1 = 0 ;
21570 PyObject *swig_obj[1] ;
21571
21572 if (!args) SWIG_fail;
21573 swig_obj[0] = args;
21574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21575 if (!SWIG_IsOK(res1)) {
21576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21577 }
21578 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21579 result = (int) ((arg1)->m_wheelRotation);
21580 resultobj = SWIG_From_int(static_cast< int >(result));
21581 return resultobj;
21582 fail:
21583 return NULL;
21584 }
21585
21586
21587 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21588 PyObject *resultobj = 0;
21589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21590 int arg2 ;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 int val2 ;
21594 int ecode2 = 0 ;
21595 PyObject *swig_obj[2] ;
21596
21597 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21604 if (!SWIG_IsOK(ecode2)) {
21605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21606 }
21607 arg2 = static_cast< int >(val2);
21608 if (arg1) (arg1)->m_wheelDelta = arg2;
21609
21610 resultobj = SWIG_Py_Void();
21611 return resultobj;
21612 fail:
21613 return NULL;
21614 }
21615
21616
21617 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21618 PyObject *resultobj = 0;
21619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21620 int result;
21621 void *argp1 = 0 ;
21622 int res1 = 0 ;
21623 PyObject *swig_obj[1] ;
21624
21625 if (!args) SWIG_fail;
21626 swig_obj[0] = args;
21627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21628 if (!SWIG_IsOK(res1)) {
21629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21630 }
21631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21632 result = (int) ((arg1)->m_wheelDelta);
21633 resultobj = SWIG_From_int(static_cast< int >(result));
21634 return resultobj;
21635 fail:
21636 return NULL;
21637 }
21638
21639
21640 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 PyObject *resultobj = 0;
21642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21643 int arg2 ;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 int val2 ;
21647 int ecode2 = 0 ;
21648 PyObject *swig_obj[2] ;
21649
21650 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21652 if (!SWIG_IsOK(res1)) {
21653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21654 }
21655 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21656 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21657 if (!SWIG_IsOK(ecode2)) {
21658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21659 }
21660 arg2 = static_cast< int >(val2);
21661 if (arg1) (arg1)->m_linesPerAction = arg2;
21662
21663 resultobj = SWIG_Py_Void();
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21671 PyObject *resultobj = 0;
21672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21673 int result;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 PyObject *swig_obj[1] ;
21677
21678 if (!args) SWIG_fail;
21679 swig_obj[0] = args;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21683 }
21684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21685 result = (int) ((arg1)->m_linesPerAction);
21686 resultobj = SWIG_From_int(static_cast< int >(result));
21687 return resultobj;
21688 fail:
21689 return NULL;
21690 }
21691
21692
21693 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21694 PyObject *obj;
21695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21696 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21697 return SWIG_Py_Void();
21698 }
21699
21700 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21701 return SWIG_Python_InitShadowInstance(args);
21702 }
21703
21704 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj = 0;
21706 int arg1 = (int) 0 ;
21707 int arg2 = (int) 0 ;
21708 wxSetCursorEvent *result = 0 ;
21709 int val1 ;
21710 int ecode1 = 0 ;
21711 int val2 ;
21712 int ecode2 = 0 ;
21713 PyObject * obj0 = 0 ;
21714 PyObject * obj1 = 0 ;
21715 char * kwnames[] = {
21716 (char *) "x",(char *) "y", NULL
21717 };
21718
21719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21720 if (obj0) {
21721 ecode1 = SWIG_AsVal_int(obj0, &val1);
21722 if (!SWIG_IsOK(ecode1)) {
21723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21724 }
21725 arg1 = static_cast< int >(val1);
21726 }
21727 if (obj1) {
21728 ecode2 = SWIG_AsVal_int(obj1, &val2);
21729 if (!SWIG_IsOK(ecode2)) {
21730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21731 }
21732 arg2 = static_cast< int >(val2);
21733 }
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21741 return resultobj;
21742 fail:
21743 return NULL;
21744 }
21745
21746
21747 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 PyObject *resultobj = 0;
21749 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21750 int result;
21751 void *argp1 = 0 ;
21752 int res1 = 0 ;
21753 PyObject *swig_obj[1] ;
21754
21755 if (!args) SWIG_fail;
21756 swig_obj[0] = args;
21757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21758 if (!SWIG_IsOK(res1)) {
21759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21760 }
21761 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21762 {
21763 PyThreadState* __tstate = wxPyBeginAllowThreads();
21764 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 resultobj = SWIG_From_int(static_cast< int >(result));
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 PyObject *resultobj = 0;
21777 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21778 int result;
21779 void *argp1 = 0 ;
21780 int res1 = 0 ;
21781 PyObject *swig_obj[1] ;
21782
21783 if (!args) SWIG_fail;
21784 swig_obj[0] = args;
21785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21788 }
21789 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 resultobj = SWIG_From_int(static_cast< int >(result));
21797 return resultobj;
21798 fail:
21799 return NULL;
21800 }
21801
21802
21803 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21804 PyObject *resultobj = 0;
21805 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21806 wxCursor *arg2 = 0 ;
21807 void *argp1 = 0 ;
21808 int res1 = 0 ;
21809 void *argp2 = 0 ;
21810 int res2 = 0 ;
21811 PyObject * obj0 = 0 ;
21812 PyObject * obj1 = 0 ;
21813 char * kwnames[] = {
21814 (char *) "self",(char *) "cursor", NULL
21815 };
21816
21817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21819 if (!SWIG_IsOK(res1)) {
21820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21821 }
21822 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21824 if (!SWIG_IsOK(res2)) {
21825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21826 }
21827 if (!argp2) {
21828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21829 }
21830 arg2 = reinterpret_cast< wxCursor * >(argp2);
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->SetCursor((wxCursor const &)*arg2);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_Py_Void();
21838 return resultobj;
21839 fail:
21840 return NULL;
21841 }
21842
21843
21844 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21845 PyObject *resultobj = 0;
21846 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21847 wxCursor *result = 0 ;
21848 void *argp1 = 0 ;
21849 int res1 = 0 ;
21850 PyObject *swig_obj[1] ;
21851
21852 if (!args) SWIG_fail;
21853 swig_obj[0] = args;
21854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21855 if (!SWIG_IsOK(res1)) {
21856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21857 }
21858 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 {
21862 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21863 result = (wxCursor *) &_result_ref;
21864 }
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 {
21869 wxCursor* resultptr = new wxCursor(*result);
21870 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21871 }
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *resultobj = 0;
21880 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21881 bool result;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 PyObject *swig_obj[1] ;
21885
21886 if (!args) SWIG_fail;
21887 swig_obj[0] = args;
21888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21889 if (!SWIG_IsOK(res1)) {
21890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21891 }
21892 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 {
21900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21901 }
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21909 PyObject *obj;
21910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21911 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21912 return SWIG_Py_Void();
21913 }
21914
21915 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 return SWIG_Python_InitShadowInstance(args);
21917 }
21918
21919 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21920 PyObject *resultobj = 0;
21921 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21922 wxKeyEvent *result = 0 ;
21923 int val1 ;
21924 int ecode1 = 0 ;
21925 PyObject * obj0 = 0 ;
21926 char * kwnames[] = {
21927 (char *) "eventType", NULL
21928 };
21929
21930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21931 if (obj0) {
21932 ecode1 = SWIG_AsVal_int(obj0, &val1);
21933 if (!SWIG_IsOK(ecode1)) {
21934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21935 }
21936 arg1 = static_cast< wxEventType >(val1);
21937 }
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21945 return resultobj;
21946 fail:
21947 return NULL;
21948 }
21949
21950
21951 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21952 PyObject *resultobj = 0;
21953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21954 int result;
21955 void *argp1 = 0 ;
21956 int res1 = 0 ;
21957 PyObject *swig_obj[1] ;
21958
21959 if (!args) SWIG_fail;
21960 swig_obj[0] = args;
21961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21964 }
21965 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21966 {
21967 PyThreadState* __tstate = wxPyBeginAllowThreads();
21968 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21969 wxPyEndAllowThreads(__tstate);
21970 if (PyErr_Occurred()) SWIG_fail;
21971 }
21972 resultobj = SWIG_From_int(static_cast< int >(result));
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21980 PyObject *resultobj = 0;
21981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21982 bool result;
21983 void *argp1 = 0 ;
21984 int res1 = 0 ;
21985 PyObject *swig_obj[1] ;
21986
21987 if (!args) SWIG_fail;
21988 swig_obj[0] = args;
21989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21990 if (!SWIG_IsOK(res1)) {
21991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21992 }
21993 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 {
22001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22002 }
22003 return resultobj;
22004 fail:
22005 return NULL;
22006 }
22007
22008
22009 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22010 PyObject *resultobj = 0;
22011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22012 bool result;
22013 void *argp1 = 0 ;
22014 int res1 = 0 ;
22015 PyObject *swig_obj[1] ;
22016
22017 if (!args) SWIG_fail;
22018 swig_obj[0] = args;
22019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22020 if (!SWIG_IsOK(res1)) {
22021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22022 }
22023 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22027 wxPyEndAllowThreads(__tstate);
22028 if (PyErr_Occurred()) SWIG_fail;
22029 }
22030 {
22031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22032 }
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22042 bool result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22052 }
22053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22072 bool result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22100 PyObject *resultobj = 0;
22101 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22102 bool result;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 PyObject *swig_obj[1] ;
22106
22107 if (!args) SWIG_fail;
22108 swig_obj[0] = args;
22109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22112 }
22113 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22122 }
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22130 PyObject *resultobj = 0;
22131 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22132 bool result;
22133 void *argp1 = 0 ;
22134 int res1 = 0 ;
22135 PyObject *swig_obj[1] ;
22136
22137 if (!args) SWIG_fail;
22138 swig_obj[0] = args;
22139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22140 if (!SWIG_IsOK(res1)) {
22141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22142 }
22143 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22144 {
22145 PyThreadState* __tstate = wxPyBeginAllowThreads();
22146 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 {
22151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22152 }
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22160 PyObject *resultobj = 0;
22161 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22162 int result;
22163 void *argp1 = 0 ;
22164 int res1 = 0 ;
22165 PyObject *swig_obj[1] ;
22166
22167 if (!args) SWIG_fail;
22168 swig_obj[0] = args;
22169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22170 if (!SWIG_IsOK(res1)) {
22171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22172 }
22173 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 resultobj = SWIG_From_int(static_cast< int >(result));
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(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_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22200 }
22201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
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_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj = 0;
22217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22218 int arg2 ;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 int val2 ;
22222 int ecode2 = 0 ;
22223 PyObject * obj0 = 0 ;
22224 PyObject * obj1 = 0 ;
22225 char * kwnames[] = {
22226 (char *) "self",(char *) "uniChar", NULL
22227 };
22228
22229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22231 if (!SWIG_IsOK(res1)) {
22232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22233 }
22234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22235 ecode2 = SWIG_AsVal_int(obj1, &val2);
22236 if (!SWIG_IsOK(ecode2)) {
22237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22238 }
22239 arg2 = static_cast< int >(val2);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_Py_Void();
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *resultobj = 0;
22255 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22256 unsigned int result;
22257 void *argp1 = 0 ;
22258 int res1 = 0 ;
22259 PyObject *swig_obj[1] ;
22260
22261 if (!args) SWIG_fail;
22262 swig_obj[0] = args;
22263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22266 }
22267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22284 unsigned int result;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 PyObject *swig_obj[1] ;
22288
22289 if (!args) SWIG_fail;
22290 swig_obj[0] = args;
22291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22292 if (!SWIG_IsOK(res1)) {
22293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22294 }
22295 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22310 PyObject *resultobj = 0;
22311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22312 wxPoint result;
22313 void *argp1 = 0 ;
22314 int res1 = 0 ;
22315 PyObject *swig_obj[1] ;
22316
22317 if (!args) SWIG_fail;
22318 swig_obj[0] = args;
22319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22320 if (!SWIG_IsOK(res1)) {
22321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22322 }
22323 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (arg1)->GetPosition();
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22338 PyObject *resultobj = 0;
22339 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22340 long *arg2 = (long *) 0 ;
22341 long *arg3 = (long *) 0 ;
22342 void *argp1 = 0 ;
22343 int res1 = 0 ;
22344 long temp2 ;
22345 int res2 = SWIG_TMPOBJ ;
22346 long temp3 ;
22347 int res3 = SWIG_TMPOBJ ;
22348 PyObject *swig_obj[1] ;
22349
22350 arg2 = &temp2;
22351 arg3 = &temp3;
22352 if (!args) SWIG_fail;
22353 swig_obj[0] = args;
22354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22355 if (!SWIG_IsOK(res1)) {
22356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22357 }
22358 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 (arg1)->GetPosition(arg2,arg3);
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_Py_Void();
22366 if (SWIG_IsTmpObj(res2)) {
22367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22368 } else {
22369 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22371 }
22372 if (SWIG_IsTmpObj(res3)) {
22373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22374 } else {
22375 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22377 }
22378 return resultobj;
22379 fail:
22380 return NULL;
22381 }
22382
22383
22384 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22385 PyObject *resultobj = 0;
22386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22387 int result;
22388 void *argp1 = 0 ;
22389 int res1 = 0 ;
22390 PyObject *swig_obj[1] ;
22391
22392 if (!args) SWIG_fail;
22393 swig_obj[0] = args;
22394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22395 if (!SWIG_IsOK(res1)) {
22396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22397 }
22398 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 result = (int)((wxKeyEvent const *)arg1)->GetX();
22402 wxPyEndAllowThreads(__tstate);
22403 if (PyErr_Occurred()) SWIG_fail;
22404 }
22405 resultobj = SWIG_From_int(static_cast< int >(result));
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22413 PyObject *resultobj = 0;
22414 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22415 int result;
22416 void *argp1 = 0 ;
22417 int res1 = 0 ;
22418 PyObject *swig_obj[1] ;
22419
22420 if (!args) SWIG_fail;
22421 swig_obj[0] = args;
22422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22423 if (!SWIG_IsOK(res1)) {
22424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22425 }
22426 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (int)((wxKeyEvent const *)arg1)->GetY();
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 resultobj = SWIG_From_int(static_cast< int >(result));
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22441 PyObject *resultobj = 0;
22442 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22443 int arg2 ;
22444 void *argp1 = 0 ;
22445 int res1 = 0 ;
22446 int val2 ;
22447 int ecode2 = 0 ;
22448 PyObject *swig_obj[2] ;
22449
22450 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22454 }
22455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22456 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22457 if (!SWIG_IsOK(ecode2)) {
22458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22459 }
22460 arg2 = static_cast< int >(val2);
22461 if (arg1) (arg1)->m_x = arg2;
22462
22463 resultobj = SWIG_Py_Void();
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22471 PyObject *resultobj = 0;
22472 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22473 int result;
22474 void *argp1 = 0 ;
22475 int res1 = 0 ;
22476 PyObject *swig_obj[1] ;
22477
22478 if (!args) SWIG_fail;
22479 swig_obj[0] = args;
22480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22481 if (!SWIG_IsOK(res1)) {
22482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22483 }
22484 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22485 result = (int) ((arg1)->m_x);
22486 resultobj = SWIG_From_int(static_cast< int >(result));
22487 return resultobj;
22488 fail:
22489 return NULL;
22490 }
22491
22492
22493 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22494 PyObject *resultobj = 0;
22495 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22496 int arg2 ;
22497 void *argp1 = 0 ;
22498 int res1 = 0 ;
22499 int val2 ;
22500 int ecode2 = 0 ;
22501 PyObject *swig_obj[2] ;
22502
22503 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22507 }
22508 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22509 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22510 if (!SWIG_IsOK(ecode2)) {
22511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22512 }
22513 arg2 = static_cast< int >(val2);
22514 if (arg1) (arg1)->m_y = arg2;
22515
22516 resultobj = SWIG_Py_Void();
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22524 PyObject *resultobj = 0;
22525 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22526 int result;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 PyObject *swig_obj[1] ;
22530
22531 if (!args) SWIG_fail;
22532 swig_obj[0] = args;
22533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22534 if (!SWIG_IsOK(res1)) {
22535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22536 }
22537 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22538 result = (int) ((arg1)->m_y);
22539 resultobj = SWIG_From_int(static_cast< int >(result));
22540 return resultobj;
22541 fail:
22542 return NULL;
22543 }
22544
22545
22546 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22547 PyObject *resultobj = 0;
22548 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22549 long arg2 ;
22550 void *argp1 = 0 ;
22551 int res1 = 0 ;
22552 long val2 ;
22553 int ecode2 = 0 ;
22554 PyObject *swig_obj[2] ;
22555
22556 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22558 if (!SWIG_IsOK(res1)) {
22559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22560 }
22561 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22562 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22563 if (!SWIG_IsOK(ecode2)) {
22564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22565 }
22566 arg2 = static_cast< long >(val2);
22567 if (arg1) (arg1)->m_keyCode = arg2;
22568
22569 resultobj = SWIG_Py_Void();
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22577 PyObject *resultobj = 0;
22578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22579 long result;
22580 void *argp1 = 0 ;
22581 int res1 = 0 ;
22582 PyObject *swig_obj[1] ;
22583
22584 if (!args) SWIG_fail;
22585 swig_obj[0] = args;
22586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22587 if (!SWIG_IsOK(res1)) {
22588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22589 }
22590 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22591 result = (long) ((arg1)->m_keyCode);
22592 resultobj = SWIG_From_long(static_cast< long >(result));
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *resultobj = 0;
22601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22602 bool arg2 ;
22603 void *argp1 = 0 ;
22604 int res1 = 0 ;
22605 bool val2 ;
22606 int ecode2 = 0 ;
22607 PyObject *swig_obj[2] ;
22608
22609 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22611 if (!SWIG_IsOK(res1)) {
22612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22613 }
22614 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22615 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22616 if (!SWIG_IsOK(ecode2)) {
22617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22618 }
22619 arg2 = static_cast< bool >(val2);
22620 if (arg1) (arg1)->m_controlDown = arg2;
22621
22622 resultobj = SWIG_Py_Void();
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22630 PyObject *resultobj = 0;
22631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22632 bool result;
22633 void *argp1 = 0 ;
22634 int res1 = 0 ;
22635 PyObject *swig_obj[1] ;
22636
22637 if (!args) SWIG_fail;
22638 swig_obj[0] = args;
22639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22640 if (!SWIG_IsOK(res1)) {
22641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22642 }
22643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22644 result = (bool) ((arg1)->m_controlDown);
22645 {
22646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22647 }
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22655 PyObject *resultobj = 0;
22656 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22657 bool arg2 ;
22658 void *argp1 = 0 ;
22659 int res1 = 0 ;
22660 bool val2 ;
22661 int ecode2 = 0 ;
22662 PyObject *swig_obj[2] ;
22663
22664 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22666 if (!SWIG_IsOK(res1)) {
22667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22668 }
22669 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22670 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22671 if (!SWIG_IsOK(ecode2)) {
22672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22673 }
22674 arg2 = static_cast< bool >(val2);
22675 if (arg1) (arg1)->m_shiftDown = arg2;
22676
22677 resultobj = SWIG_Py_Void();
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22685 PyObject *resultobj = 0;
22686 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22687 bool result;
22688 void *argp1 = 0 ;
22689 int res1 = 0 ;
22690 PyObject *swig_obj[1] ;
22691
22692 if (!args) SWIG_fail;
22693 swig_obj[0] = args;
22694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22695 if (!SWIG_IsOK(res1)) {
22696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22697 }
22698 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22699 result = (bool) ((arg1)->m_shiftDown);
22700 {
22701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22702 }
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *resultobj = 0;
22711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22712 bool arg2 ;
22713 void *argp1 = 0 ;
22714 int res1 = 0 ;
22715 bool val2 ;
22716 int ecode2 = 0 ;
22717 PyObject *swig_obj[2] ;
22718
22719 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22721 if (!SWIG_IsOK(res1)) {
22722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22723 }
22724 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22725 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22726 if (!SWIG_IsOK(ecode2)) {
22727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22728 }
22729 arg2 = static_cast< bool >(val2);
22730 if (arg1) (arg1)->m_altDown = arg2;
22731
22732 resultobj = SWIG_Py_Void();
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 PyObject *resultobj = 0;
22741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22742 bool result;
22743 void *argp1 = 0 ;
22744 int res1 = 0 ;
22745 PyObject *swig_obj[1] ;
22746
22747 if (!args) SWIG_fail;
22748 swig_obj[0] = args;
22749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22750 if (!SWIG_IsOK(res1)) {
22751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22752 }
22753 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22754 result = (bool) ((arg1)->m_altDown);
22755 {
22756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22757 }
22758 return resultobj;
22759 fail:
22760 return NULL;
22761 }
22762
22763
22764 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22765 PyObject *resultobj = 0;
22766 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22767 bool arg2 ;
22768 void *argp1 = 0 ;
22769 int res1 = 0 ;
22770 bool val2 ;
22771 int ecode2 = 0 ;
22772 PyObject *swig_obj[2] ;
22773
22774 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22776 if (!SWIG_IsOK(res1)) {
22777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22778 }
22779 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22780 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22781 if (!SWIG_IsOK(ecode2)) {
22782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22783 }
22784 arg2 = static_cast< bool >(val2);
22785 if (arg1) (arg1)->m_metaDown = arg2;
22786
22787 resultobj = SWIG_Py_Void();
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22795 PyObject *resultobj = 0;
22796 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22797 bool result;
22798 void *argp1 = 0 ;
22799 int res1 = 0 ;
22800 PyObject *swig_obj[1] ;
22801
22802 if (!args) SWIG_fail;
22803 swig_obj[0] = args;
22804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22805 if (!SWIG_IsOK(res1)) {
22806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22807 }
22808 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22809 result = (bool) ((arg1)->m_metaDown);
22810 {
22811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22812 }
22813 return resultobj;
22814 fail:
22815 return NULL;
22816 }
22817
22818
22819 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22820 PyObject *resultobj = 0;
22821 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22822 bool arg2 ;
22823 void *argp1 = 0 ;
22824 int res1 = 0 ;
22825 bool val2 ;
22826 int ecode2 = 0 ;
22827 PyObject *swig_obj[2] ;
22828
22829 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22831 if (!SWIG_IsOK(res1)) {
22832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22833 }
22834 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22835 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22836 if (!SWIG_IsOK(ecode2)) {
22837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22838 }
22839 arg2 = static_cast< bool >(val2);
22840 if (arg1) (arg1)->m_scanCode = arg2;
22841
22842 resultobj = SWIG_Py_Void();
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22850 PyObject *resultobj = 0;
22851 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22852 bool result;
22853 void *argp1 = 0 ;
22854 int res1 = 0 ;
22855 PyObject *swig_obj[1] ;
22856
22857 if (!args) SWIG_fail;
22858 swig_obj[0] = args;
22859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22860 if (!SWIG_IsOK(res1)) {
22861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22862 }
22863 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22864 result = (bool) ((arg1)->m_scanCode);
22865 {
22866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22867 }
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22875 PyObject *resultobj = 0;
22876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22877 unsigned int arg2 ;
22878 void *argp1 = 0 ;
22879 int res1 = 0 ;
22880 unsigned int val2 ;
22881 int ecode2 = 0 ;
22882 PyObject *swig_obj[2] ;
22883
22884 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22888 }
22889 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22890 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22893 }
22894 arg2 = static_cast< unsigned int >(val2);
22895 if (arg1) (arg1)->m_rawCode = arg2;
22896
22897 resultobj = SWIG_Py_Void();
22898 return resultobj;
22899 fail:
22900 return NULL;
22901 }
22902
22903
22904 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22905 PyObject *resultobj = 0;
22906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22907 unsigned int result;
22908 void *argp1 = 0 ;
22909 int res1 = 0 ;
22910 PyObject *swig_obj[1] ;
22911
22912 if (!args) SWIG_fail;
22913 swig_obj[0] = args;
22914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22915 if (!SWIG_IsOK(res1)) {
22916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22917 }
22918 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22919 result = (unsigned int) ((arg1)->m_rawCode);
22920 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22928 PyObject *resultobj = 0;
22929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22930 unsigned int arg2 ;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 unsigned int val2 ;
22934 int ecode2 = 0 ;
22935 PyObject *swig_obj[2] ;
22936
22937 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22941 }
22942 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22943 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22944 if (!SWIG_IsOK(ecode2)) {
22945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22946 }
22947 arg2 = static_cast< unsigned int >(val2);
22948 if (arg1) (arg1)->m_rawFlags = arg2;
22949
22950 resultobj = SWIG_Py_Void();
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22958 PyObject *resultobj = 0;
22959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22960 unsigned int result;
22961 void *argp1 = 0 ;
22962 int res1 = 0 ;
22963 PyObject *swig_obj[1] ;
22964
22965 if (!args) SWIG_fail;
22966 swig_obj[0] = args;
22967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22968 if (!SWIG_IsOK(res1)) {
22969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22970 }
22971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22972 result = (unsigned int) ((arg1)->m_rawFlags);
22973 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22981 PyObject *obj;
22982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22983 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22984 return SWIG_Py_Void();
22985 }
22986
22987 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22988 return SWIG_Python_InitShadowInstance(args);
22989 }
22990
22991 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22992 PyObject *resultobj = 0;
22993 wxSize const &arg1_defvalue = wxDefaultSize ;
22994 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22995 int arg2 = (int) 0 ;
22996 wxSizeEvent *result = 0 ;
22997 wxSize temp1 ;
22998 int val2 ;
22999 int ecode2 = 0 ;
23000 PyObject * obj0 = 0 ;
23001 PyObject * obj1 = 0 ;
23002 char * kwnames[] = {
23003 (char *) "sz",(char *) "winid", NULL
23004 };
23005
23006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23007 if (obj0) {
23008 {
23009 arg1 = &temp1;
23010 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23011 }
23012 }
23013 if (obj1) {
23014 ecode2 = SWIG_AsVal_int(obj1, &val2);
23015 if (!SWIG_IsOK(ecode2)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23017 }
23018 arg2 = static_cast< int >(val2);
23019 }
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23034 PyObject *resultobj = 0;
23035 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23036 wxSize result;
23037 void *argp1 = 0 ;
23038 int res1 = 0 ;
23039 PyObject *swig_obj[1] ;
23040
23041 if (!args) SWIG_fail;
23042 swig_obj[0] = args;
23043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23044 if (!SWIG_IsOK(res1)) {
23045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23046 }
23047 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 result = ((wxSizeEvent const *)arg1)->GetSize();
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23064 wxRect result;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 PyObject *swig_obj[1] ;
23068
23069 if (!args) SWIG_fail;
23070 swig_obj[0] = args;
23071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23072 if (!SWIG_IsOK(res1)) {
23073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23074 }
23075 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 result = ((wxSizeEvent const *)arg1)->GetRect();
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23083 return resultobj;
23084 fail:
23085 return NULL;
23086 }
23087
23088
23089 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23090 PyObject *resultobj = 0;
23091 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23092 wxRect arg2 ;
23093 void *argp1 = 0 ;
23094 int res1 = 0 ;
23095 void *argp2 ;
23096 int res2 = 0 ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char * kwnames[] = {
23100 (char *) "self",(char *) "rect", NULL
23101 };
23102
23103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23107 }
23108 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23109 {
23110 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23111 if (!SWIG_IsOK(res2)) {
23112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23113 }
23114 if (!argp2) {
23115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23116 } else {
23117 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23118 arg2 = *temp;
23119 if (SWIG_IsNewObj(res2)) delete temp;
23120 }
23121 }
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 (arg1)->SetRect(arg2);
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 resultobj = SWIG_Py_Void();
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj = 0;
23137 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23138 wxSize arg2 ;
23139 void *argp1 = 0 ;
23140 int res1 = 0 ;
23141 void *argp2 ;
23142 int res2 = 0 ;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 char * kwnames[] = {
23146 (char *) "self",(char *) "size", NULL
23147 };
23148
23149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23151 if (!SWIG_IsOK(res1)) {
23152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23153 }
23154 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23155 {
23156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23157 if (!SWIG_IsOK(res2)) {
23158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23159 }
23160 if (!argp2) {
23161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23162 } else {
23163 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23164 arg2 = *temp;
23165 if (SWIG_IsNewObj(res2)) delete temp;
23166 }
23167 }
23168 {
23169 PyThreadState* __tstate = wxPyBeginAllowThreads();
23170 wxSizeEvent_SetSize(arg1,arg2);
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 resultobj = SWIG_Py_Void();
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23182 PyObject *resultobj = 0;
23183 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23184 wxSize *arg2 = (wxSize *) 0 ;
23185 void *argp1 = 0 ;
23186 int res1 = 0 ;
23187 void *argp2 = 0 ;
23188 int res2 = 0 ;
23189 PyObject *swig_obj[2] ;
23190
23191 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23193 if (!SWIG_IsOK(res1)) {
23194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23195 }
23196 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23197 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23198 if (!SWIG_IsOK(res2)) {
23199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23200 }
23201 arg2 = reinterpret_cast< wxSize * >(argp2);
23202 if (arg1) (arg1)->m_size = *arg2;
23203
23204 resultobj = SWIG_Py_Void();
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23212 PyObject *resultobj = 0;
23213 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23214 wxSize *result = 0 ;
23215 void *argp1 = 0 ;
23216 int res1 = 0 ;
23217 PyObject *swig_obj[1] ;
23218
23219 if (!args) SWIG_fail;
23220 swig_obj[0] = args;
23221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23222 if (!SWIG_IsOK(res1)) {
23223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23224 }
23225 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23226 result = (wxSize *)& ((arg1)->m_size);
23227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23228 return resultobj;
23229 fail:
23230 return NULL;
23231 }
23232
23233
23234 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23235 PyObject *resultobj = 0;
23236 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23237 wxRect *arg2 = (wxRect *) 0 ;
23238 void *argp1 = 0 ;
23239 int res1 = 0 ;
23240 void *argp2 = 0 ;
23241 int res2 = 0 ;
23242 PyObject *swig_obj[2] ;
23243
23244 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23246 if (!SWIG_IsOK(res1)) {
23247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23248 }
23249 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23250 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23251 if (!SWIG_IsOK(res2)) {
23252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23253 }
23254 arg2 = reinterpret_cast< wxRect * >(argp2);
23255 if (arg1) (arg1)->m_rect = *arg2;
23256
23257 resultobj = SWIG_Py_Void();
23258 return resultobj;
23259 fail:
23260 return NULL;
23261 }
23262
23263
23264 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23265 PyObject *resultobj = 0;
23266 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23267 wxRect *result = 0 ;
23268 void *argp1 = 0 ;
23269 int res1 = 0 ;
23270 PyObject *swig_obj[1] ;
23271
23272 if (!args) SWIG_fail;
23273 swig_obj[0] = args;
23274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23275 if (!SWIG_IsOK(res1)) {
23276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23277 }
23278 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23279 result = (wxRect *)& ((arg1)->m_rect);
23280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23288 PyObject *obj;
23289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23290 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23291 return SWIG_Py_Void();
23292 }
23293
23294 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23295 return SWIG_Python_InitShadowInstance(args);
23296 }
23297
23298 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj = 0;
23300 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23301 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23302 int arg2 = (int) 0 ;
23303 wxMoveEvent *result = 0 ;
23304 wxPoint temp1 ;
23305 int val2 ;
23306 int ecode2 = 0 ;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char * kwnames[] = {
23310 (char *) "pos",(char *) "winid", NULL
23311 };
23312
23313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23314 if (obj0) {
23315 {
23316 arg1 = &temp1;
23317 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23318 }
23319 }
23320 if (obj1) {
23321 ecode2 = SWIG_AsVal_int(obj1, &val2);
23322 if (!SWIG_IsOK(ecode2)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23324 }
23325 arg2 = static_cast< int >(val2);
23326 }
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23341 PyObject *resultobj = 0;
23342 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23343 wxPoint result;
23344 void *argp1 = 0 ;
23345 int res1 = 0 ;
23346 PyObject *swig_obj[1] ;
23347
23348 if (!args) SWIG_fail;
23349 swig_obj[0] = args;
23350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23351 if (!SWIG_IsOK(res1)) {
23352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23353 }
23354 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = ((wxMoveEvent const *)arg1)->GetPosition();
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23369 PyObject *resultobj = 0;
23370 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23371 wxRect result;
23372 void *argp1 = 0 ;
23373 int res1 = 0 ;
23374 PyObject *swig_obj[1] ;
23375
23376 if (!args) SWIG_fail;
23377 swig_obj[0] = args;
23378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23379 if (!SWIG_IsOK(res1)) {
23380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23381 }
23382 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = ((wxMoveEvent const *)arg1)->GetRect();
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23390 return resultobj;
23391 fail:
23392 return NULL;
23393 }
23394
23395
23396 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23397 PyObject *resultobj = 0;
23398 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23399 wxRect *arg2 = 0 ;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 wxRect temp2 ;
23403 PyObject * obj0 = 0 ;
23404 PyObject * obj1 = 0 ;
23405 char * kwnames[] = {
23406 (char *) "self",(char *) "rect", NULL
23407 };
23408
23409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23411 if (!SWIG_IsOK(res1)) {
23412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23413 }
23414 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23415 {
23416 arg2 = &temp2;
23417 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23418 }
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 (arg1)->SetRect((wxRect const &)*arg2);
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 resultobj = SWIG_Py_Void();
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23433 PyObject *resultobj = 0;
23434 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23435 wxPoint *arg2 = 0 ;
23436 void *argp1 = 0 ;
23437 int res1 = 0 ;
23438 wxPoint temp2 ;
23439 PyObject * obj0 = 0 ;
23440 PyObject * obj1 = 0 ;
23441 char * kwnames[] = {
23442 (char *) "self",(char *) "pos", NULL
23443 };
23444
23445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23447 if (!SWIG_IsOK(res1)) {
23448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23449 }
23450 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23451 {
23452 arg2 = &temp2;
23453 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23454 }
23455 {
23456 PyThreadState* __tstate = wxPyBeginAllowThreads();
23457 (arg1)->SetPosition((wxPoint const &)*arg2);
23458 wxPyEndAllowThreads(__tstate);
23459 if (PyErr_Occurred()) SWIG_fail;
23460 }
23461 resultobj = SWIG_Py_Void();
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469 PyObject *obj;
23470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23471 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23472 return SWIG_Py_Void();
23473 }
23474
23475 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23476 return SWIG_Python_InitShadowInstance(args);
23477 }
23478
23479 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj = 0;
23481 int arg1 = (int) 0 ;
23482 wxPaintEvent *result = 0 ;
23483 int val1 ;
23484 int ecode1 = 0 ;
23485 PyObject * obj0 = 0 ;
23486 char * kwnames[] = {
23487 (char *) "Id", NULL
23488 };
23489
23490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23491 if (obj0) {
23492 ecode1 = SWIG_AsVal_int(obj0, &val1);
23493 if (!SWIG_IsOK(ecode1)) {
23494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23495 }
23496 arg1 = static_cast< int >(val1);
23497 }
23498 {
23499 PyThreadState* __tstate = wxPyBeginAllowThreads();
23500 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23501 wxPyEndAllowThreads(__tstate);
23502 if (PyErr_Occurred()) SWIG_fail;
23503 }
23504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23512 PyObject *obj;
23513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23514 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23515 return SWIG_Py_Void();
23516 }
23517
23518 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23519 return SWIG_Python_InitShadowInstance(args);
23520 }
23521
23522 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj = 0;
23524 int arg1 = (int) 0 ;
23525 wxNcPaintEvent *result = 0 ;
23526 int val1 ;
23527 int ecode1 = 0 ;
23528 PyObject * obj0 = 0 ;
23529 char * kwnames[] = {
23530 (char *) "winid", NULL
23531 };
23532
23533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23534 if (obj0) {
23535 ecode1 = SWIG_AsVal_int(obj0, &val1);
23536 if (!SWIG_IsOK(ecode1)) {
23537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23538 }
23539 arg1 = static_cast< int >(val1);
23540 }
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23555 PyObject *obj;
23556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23557 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23558 return SWIG_Py_Void();
23559 }
23560
23561 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23562 return SWIG_Python_InitShadowInstance(args);
23563 }
23564
23565 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 int arg1 = (int) 0 ;
23568 wxDC *arg2 = (wxDC *) NULL ;
23569 wxEraseEvent *result = 0 ;
23570 int val1 ;
23571 int ecode1 = 0 ;
23572 void *argp2 = 0 ;
23573 int res2 = 0 ;
23574 PyObject * obj0 = 0 ;
23575 PyObject * obj1 = 0 ;
23576 char * kwnames[] = {
23577 (char *) "Id",(char *) "dc", NULL
23578 };
23579
23580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23581 if (obj0) {
23582 ecode1 = SWIG_AsVal_int(obj0, &val1);
23583 if (!SWIG_IsOK(ecode1)) {
23584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23585 }
23586 arg1 = static_cast< int >(val1);
23587 }
23588 if (obj1) {
23589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23590 if (!SWIG_IsOK(res2)) {
23591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23592 }
23593 arg2 = reinterpret_cast< wxDC * >(argp2);
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 PyObject *resultobj = 0;
23610 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23611 wxDC *result = 0 ;
23612 void *argp1 = 0 ;
23613 int res1 = 0 ;
23614 PyObject *swig_obj[1] ;
23615
23616 if (!args) SWIG_fail;
23617 swig_obj[0] = args;
23618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23621 }
23622 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 {
23630 resultobj = wxPyMake_wxObject(result, (bool)0);
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23639 PyObject *obj;
23640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23641 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23642 return SWIG_Py_Void();
23643 }
23644
23645 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 return SWIG_Python_InitShadowInstance(args);
23647 }
23648
23649 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23652 int arg2 = (int) 0 ;
23653 wxFocusEvent *result = 0 ;
23654 int val1 ;
23655 int ecode1 = 0 ;
23656 int val2 ;
23657 int ecode2 = 0 ;
23658 PyObject * obj0 = 0 ;
23659 PyObject * obj1 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "type",(char *) "winid", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23665 if (obj0) {
23666 ecode1 = SWIG_AsVal_int(obj0, &val1);
23667 if (!SWIG_IsOK(ecode1)) {
23668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23669 }
23670 arg1 = static_cast< wxEventType >(val1);
23671 }
23672 if (obj1) {
23673 ecode2 = SWIG_AsVal_int(obj1, &val2);
23674 if (!SWIG_IsOK(ecode2)) {
23675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23676 }
23677 arg2 = static_cast< int >(val2);
23678 }
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23682 wxPyEndAllowThreads(__tstate);
23683 if (PyErr_Occurred()) SWIG_fail;
23684 }
23685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23686 return resultobj;
23687 fail:
23688 return NULL;
23689 }
23690
23691
23692 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23693 PyObject *resultobj = 0;
23694 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23695 wxWindow *result = 0 ;
23696 void *argp1 = 0 ;
23697 int res1 = 0 ;
23698 PyObject *swig_obj[1] ;
23699
23700 if (!args) SWIG_fail;
23701 swig_obj[0] = args;
23702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23703 if (!SWIG_IsOK(res1)) {
23704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23705 }
23706 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 {
23714 resultobj = wxPyMake_wxObject(result, (bool)0);
23715 }
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj = 0;
23724 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23725 wxWindow *arg2 = (wxWindow *) 0 ;
23726 void *argp1 = 0 ;
23727 int res1 = 0 ;
23728 void *argp2 = 0 ;
23729 int res2 = 0 ;
23730 PyObject * obj0 = 0 ;
23731 PyObject * obj1 = 0 ;
23732 char * kwnames[] = {
23733 (char *) "self",(char *) "win", NULL
23734 };
23735
23736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23738 if (!SWIG_IsOK(res1)) {
23739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23740 }
23741 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23742 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23743 if (!SWIG_IsOK(res2)) {
23744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23745 }
23746 arg2 = reinterpret_cast< wxWindow * >(argp2);
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 (arg1)->SetWindow(arg2);
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 resultobj = SWIG_Py_Void();
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761 PyObject *obj;
23762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23763 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23764 return SWIG_Py_Void();
23765 }
23766
23767 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23768 return SWIG_Python_InitShadowInstance(args);
23769 }
23770
23771 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj = 0;
23773 wxWindow *arg1 = (wxWindow *) NULL ;
23774 wxChildFocusEvent *result = 0 ;
23775 void *argp1 = 0 ;
23776 int res1 = 0 ;
23777 PyObject * obj0 = 0 ;
23778 char * kwnames[] = {
23779 (char *) "win", NULL
23780 };
23781
23782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23783 if (obj0) {
23784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23785 if (!SWIG_IsOK(res1)) {
23786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23787 }
23788 arg1 = reinterpret_cast< wxWindow * >(argp1);
23789 }
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23793 wxPyEndAllowThreads(__tstate);
23794 if (PyErr_Occurred()) SWIG_fail;
23795 }
23796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23797 return resultobj;
23798 fail:
23799 return NULL;
23800 }
23801
23802
23803 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23804 PyObject *resultobj = 0;
23805 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23806 wxWindow *result = 0 ;
23807 void *argp1 = 0 ;
23808 int res1 = 0 ;
23809 PyObject *swig_obj[1] ;
23810
23811 if (!args) SWIG_fail;
23812 swig_obj[0] = args;
23813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23814 if (!SWIG_IsOK(res1)) {
23815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23816 }
23817 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23818 {
23819 PyThreadState* __tstate = wxPyBeginAllowThreads();
23820 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23821 wxPyEndAllowThreads(__tstate);
23822 if (PyErr_Occurred()) SWIG_fail;
23823 }
23824 {
23825 resultobj = wxPyMake_wxObject(result, (bool)0);
23826 }
23827 return resultobj;
23828 fail:
23829 return NULL;
23830 }
23831
23832
23833 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834 PyObject *obj;
23835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23836 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23837 return SWIG_Py_Void();
23838 }
23839
23840 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 return SWIG_Python_InitShadowInstance(args);
23842 }
23843
23844 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj = 0;
23846 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23847 bool arg2 = (bool) true ;
23848 int arg3 = (int) 0 ;
23849 wxActivateEvent *result = 0 ;
23850 int val1 ;
23851 int ecode1 = 0 ;
23852 bool val2 ;
23853 int ecode2 = 0 ;
23854 int val3 ;
23855 int ecode3 = 0 ;
23856 PyObject * obj0 = 0 ;
23857 PyObject * obj1 = 0 ;
23858 PyObject * obj2 = 0 ;
23859 char * kwnames[] = {
23860 (char *) "type",(char *) "active",(char *) "Id", NULL
23861 };
23862
23863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23864 if (obj0) {
23865 ecode1 = SWIG_AsVal_int(obj0, &val1);
23866 if (!SWIG_IsOK(ecode1)) {
23867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23868 }
23869 arg1 = static_cast< wxEventType >(val1);
23870 }
23871 if (obj1) {
23872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23873 if (!SWIG_IsOK(ecode2)) {
23874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23875 }
23876 arg2 = static_cast< bool >(val2);
23877 }
23878 if (obj2) {
23879 ecode3 = SWIG_AsVal_int(obj2, &val3);
23880 if (!SWIG_IsOK(ecode3)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23882 }
23883 arg3 = static_cast< int >(val3);
23884 }
23885 {
23886 PyThreadState* __tstate = wxPyBeginAllowThreads();
23887 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23888 wxPyEndAllowThreads(__tstate);
23889 if (PyErr_Occurred()) SWIG_fail;
23890 }
23891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23892 return resultobj;
23893 fail:
23894 return NULL;
23895 }
23896
23897
23898 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23899 PyObject *resultobj = 0;
23900 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23901 bool result;
23902 void *argp1 = 0 ;
23903 int res1 = 0 ;
23904 PyObject *swig_obj[1] ;
23905
23906 if (!args) SWIG_fail;
23907 swig_obj[0] = args;
23908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23909 if (!SWIG_IsOK(res1)) {
23910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23911 }
23912 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23916 wxPyEndAllowThreads(__tstate);
23917 if (PyErr_Occurred()) SWIG_fail;
23918 }
23919 {
23920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23921 }
23922 return resultobj;
23923 fail:
23924 return NULL;
23925 }
23926
23927
23928 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23929 PyObject *obj;
23930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23931 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23932 return SWIG_Py_Void();
23933 }
23934
23935 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 return SWIG_Python_InitShadowInstance(args);
23937 }
23938
23939 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23940 PyObject *resultobj = 0;
23941 int arg1 = (int) 0 ;
23942 wxInitDialogEvent *result = 0 ;
23943 int val1 ;
23944 int ecode1 = 0 ;
23945 PyObject * obj0 = 0 ;
23946 char * kwnames[] = {
23947 (char *) "Id", NULL
23948 };
23949
23950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23951 if (obj0) {
23952 ecode1 = SWIG_AsVal_int(obj0, &val1);
23953 if (!SWIG_IsOK(ecode1)) {
23954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23955 }
23956 arg1 = static_cast< int >(val1);
23957 }
23958 {
23959 PyThreadState* __tstate = wxPyBeginAllowThreads();
23960 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23965 return resultobj;
23966 fail:
23967 return NULL;
23968 }
23969
23970
23971 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23972 PyObject *obj;
23973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23974 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23975 return SWIG_Py_Void();
23976 }
23977
23978 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23979 return SWIG_Python_InitShadowInstance(args);
23980 }
23981
23982 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23983 PyObject *resultobj = 0;
23984 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23985 int arg2 = (int) 0 ;
23986 wxMenu *arg3 = (wxMenu *) NULL ;
23987 wxMenuEvent *result = 0 ;
23988 int val1 ;
23989 int ecode1 = 0 ;
23990 int val2 ;
23991 int ecode2 = 0 ;
23992 void *argp3 = 0 ;
23993 int res3 = 0 ;
23994 PyObject * obj0 = 0 ;
23995 PyObject * obj1 = 0 ;
23996 PyObject * obj2 = 0 ;
23997 char * kwnames[] = {
23998 (char *) "type",(char *) "winid",(char *) "menu", NULL
23999 };
24000
24001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24002 if (obj0) {
24003 ecode1 = SWIG_AsVal_int(obj0, &val1);
24004 if (!SWIG_IsOK(ecode1)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24006 }
24007 arg1 = static_cast< wxEventType >(val1);
24008 }
24009 if (obj1) {
24010 ecode2 = SWIG_AsVal_int(obj1, &val2);
24011 if (!SWIG_IsOK(ecode2)) {
24012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24013 }
24014 arg2 = static_cast< int >(val2);
24015 }
24016 if (obj2) {
24017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24018 if (!SWIG_IsOK(res3)) {
24019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24020 }
24021 arg3 = reinterpret_cast< wxMenu * >(argp3);
24022 }
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24030 return resultobj;
24031 fail:
24032 return NULL;
24033 }
24034
24035
24036 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24037 PyObject *resultobj = 0;
24038 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24039 int result;
24040 void *argp1 = 0 ;
24041 int res1 = 0 ;
24042 PyObject *swig_obj[1] ;
24043
24044 if (!args) SWIG_fail;
24045 swig_obj[0] = args;
24046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24047 if (!SWIG_IsOK(res1)) {
24048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24049 }
24050 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_From_int(static_cast< int >(result));
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065 PyObject *resultobj = 0;
24066 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24067 bool result;
24068 void *argp1 = 0 ;
24069 int res1 = 0 ;
24070 PyObject *swig_obj[1] ;
24071
24072 if (!args) SWIG_fail;
24073 swig_obj[0] = args;
24074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24075 if (!SWIG_IsOK(res1)) {
24076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24077 }
24078 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 {
24086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24087 }
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24095 PyObject *resultobj = 0;
24096 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24097 wxMenu *result = 0 ;
24098 void *argp1 = 0 ;
24099 int res1 = 0 ;
24100 PyObject *swig_obj[1] ;
24101
24102 if (!args) SWIG_fail;
24103 swig_obj[0] = args;
24104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24105 if (!SWIG_IsOK(res1)) {
24106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24107 }
24108 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24109 {
24110 PyThreadState* __tstate = wxPyBeginAllowThreads();
24111 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 {
24116 resultobj = wxPyMake_wxObject(result, (bool)0);
24117 }
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24125 PyObject *obj;
24126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24127 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24128 return SWIG_Py_Void();
24129 }
24130
24131 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24132 return SWIG_Python_InitShadowInstance(args);
24133 }
24134
24135 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24136 PyObject *resultobj = 0;
24137 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24138 int arg2 = (int) 0 ;
24139 wxCloseEvent *result = 0 ;
24140 int val1 ;
24141 int ecode1 = 0 ;
24142 int val2 ;
24143 int ecode2 = 0 ;
24144 PyObject * obj0 = 0 ;
24145 PyObject * obj1 = 0 ;
24146 char * kwnames[] = {
24147 (char *) "type",(char *) "winid", NULL
24148 };
24149
24150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24151 if (obj0) {
24152 ecode1 = SWIG_AsVal_int(obj0, &val1);
24153 if (!SWIG_IsOK(ecode1)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24155 }
24156 arg1 = static_cast< wxEventType >(val1);
24157 }
24158 if (obj1) {
24159 ecode2 = SWIG_AsVal_int(obj1, &val2);
24160 if (!SWIG_IsOK(ecode2)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24162 }
24163 arg2 = static_cast< int >(val2);
24164 }
24165 {
24166 PyThreadState* __tstate = wxPyBeginAllowThreads();
24167 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24179 PyObject *resultobj = 0;
24180 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24181 bool arg2 ;
24182 void *argp1 = 0 ;
24183 int res1 = 0 ;
24184 bool val2 ;
24185 int ecode2 = 0 ;
24186 PyObject * obj0 = 0 ;
24187 PyObject * obj1 = 0 ;
24188 char * kwnames[] = {
24189 (char *) "self",(char *) "logOff", NULL
24190 };
24191
24192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24194 if (!SWIG_IsOK(res1)) {
24195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24196 }
24197 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24198 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24199 if (!SWIG_IsOK(ecode2)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24201 }
24202 arg2 = static_cast< bool >(val2);
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 (arg1)->SetLoggingOff(arg2);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_Py_Void();
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217 PyObject *resultobj = 0;
24218 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24219 bool result;
24220 void *argp1 = 0 ;
24221 int res1 = 0 ;
24222 PyObject *swig_obj[1] ;
24223
24224 if (!args) SWIG_fail;
24225 swig_obj[0] = args;
24226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24229 }
24230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 {
24238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24239 }
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj = 0;
24248 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24249 bool arg2 = (bool) true ;
24250 void *argp1 = 0 ;
24251 int res1 = 0 ;
24252 bool val2 ;
24253 int ecode2 = 0 ;
24254 PyObject * obj0 = 0 ;
24255 PyObject * obj1 = 0 ;
24256 char * kwnames[] = {
24257 (char *) "self",(char *) "veto", NULL
24258 };
24259
24260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24264 }
24265 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24266 if (obj1) {
24267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24268 if (!SWIG_IsOK(ecode2)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24270 }
24271 arg2 = static_cast< bool >(val2);
24272 }
24273 {
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 (arg1)->Veto(arg2);
24276 wxPyEndAllowThreads(__tstate);
24277 if (PyErr_Occurred()) SWIG_fail;
24278 }
24279 resultobj = SWIG_Py_Void();
24280 return resultobj;
24281 fail:
24282 return NULL;
24283 }
24284
24285
24286 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24287 PyObject *resultobj = 0;
24288 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24289 bool result;
24290 void *argp1 = 0 ;
24291 int res1 = 0 ;
24292 PyObject *swig_obj[1] ;
24293
24294 if (!args) SWIG_fail;
24295 swig_obj[0] = args;
24296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24297 if (!SWIG_IsOK(res1)) {
24298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24299 }
24300 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24301 {
24302 PyThreadState* __tstate = wxPyBeginAllowThreads();
24303 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 {
24308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24309 }
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj = 0;
24318 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24319 bool arg2 ;
24320 void *argp1 = 0 ;
24321 int res1 = 0 ;
24322 bool val2 ;
24323 int ecode2 = 0 ;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 char * kwnames[] = {
24327 (char *) "self",(char *) "canVeto", NULL
24328 };
24329
24330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24332 if (!SWIG_IsOK(res1)) {
24333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24334 }
24335 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24336 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24337 if (!SWIG_IsOK(ecode2)) {
24338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24339 }
24340 arg2 = static_cast< bool >(val2);
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 (arg1)->SetCanVeto(arg2);
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 resultobj = SWIG_Py_Void();
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *resultobj = 0;
24356 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24357 bool result;
24358 void *argp1 = 0 ;
24359 int res1 = 0 ;
24360 PyObject *swig_obj[1] ;
24361
24362 if (!args) SWIG_fail;
24363 swig_obj[0] = args;
24364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24367 }
24368 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24369 {
24370 PyThreadState* __tstate = wxPyBeginAllowThreads();
24371 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24372 wxPyEndAllowThreads(__tstate);
24373 if (PyErr_Occurred()) SWIG_fail;
24374 }
24375 {
24376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24377 }
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24385 PyObject *obj;
24386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24387 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24388 return SWIG_Py_Void();
24389 }
24390
24391 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24392 return SWIG_Python_InitShadowInstance(args);
24393 }
24394
24395 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24396 PyObject *resultobj = 0;
24397 int arg1 = (int) 0 ;
24398 bool arg2 = (bool) false ;
24399 wxShowEvent *result = 0 ;
24400 int val1 ;
24401 int ecode1 = 0 ;
24402 bool val2 ;
24403 int ecode2 = 0 ;
24404 PyObject * obj0 = 0 ;
24405 PyObject * obj1 = 0 ;
24406 char * kwnames[] = {
24407 (char *) "winid",(char *) "show", NULL
24408 };
24409
24410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24411 if (obj0) {
24412 ecode1 = SWIG_AsVal_int(obj0, &val1);
24413 if (!SWIG_IsOK(ecode1)) {
24414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24415 }
24416 arg1 = static_cast< int >(val1);
24417 }
24418 if (obj1) {
24419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24420 if (!SWIG_IsOK(ecode2)) {
24421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24422 }
24423 arg2 = static_cast< bool >(val2);
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj = 0;
24440 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24441 bool arg2 ;
24442 void *argp1 = 0 ;
24443 int res1 = 0 ;
24444 bool val2 ;
24445 int ecode2 = 0 ;
24446 PyObject * obj0 = 0 ;
24447 PyObject * obj1 = 0 ;
24448 char * kwnames[] = {
24449 (char *) "self",(char *) "show", NULL
24450 };
24451
24452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24454 if (!SWIG_IsOK(res1)) {
24455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24456 }
24457 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24459 if (!SWIG_IsOK(ecode2)) {
24460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24461 }
24462 arg2 = static_cast< bool >(val2);
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 (arg1)->SetShow(arg2);
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_Py_Void();
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24477 PyObject *resultobj = 0;
24478 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24479 bool result;
24480 void *argp1 = 0 ;
24481 int res1 = 0 ;
24482 PyObject *swig_obj[1] ;
24483
24484 if (!args) SWIG_fail;
24485 swig_obj[0] = args;
24486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24489 }
24490 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 {
24498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24499 }
24500 return resultobj;
24501 fail:
24502 return NULL;
24503 }
24504
24505
24506 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24507 PyObject *obj;
24508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24509 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24510 return SWIG_Py_Void();
24511 }
24512
24513 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24514 return SWIG_Python_InitShadowInstance(args);
24515 }
24516
24517 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24518 PyObject *resultobj = 0;
24519 int arg1 = (int) 0 ;
24520 bool arg2 = (bool) true ;
24521 wxIconizeEvent *result = 0 ;
24522 int val1 ;
24523 int ecode1 = 0 ;
24524 bool val2 ;
24525 int ecode2 = 0 ;
24526 PyObject * obj0 = 0 ;
24527 PyObject * obj1 = 0 ;
24528 char * kwnames[] = {
24529 (char *) "id",(char *) "iconized", NULL
24530 };
24531
24532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24533 if (obj0) {
24534 ecode1 = SWIG_AsVal_int(obj0, &val1);
24535 if (!SWIG_IsOK(ecode1)) {
24536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24537 }
24538 arg1 = static_cast< int >(val1);
24539 }
24540 if (obj1) {
24541 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24542 if (!SWIG_IsOK(ecode2)) {
24543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24544 }
24545 arg2 = static_cast< bool >(val2);
24546 }
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 PyObject *resultobj = 0;
24562 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24563 bool result;
24564 void *argp1 = 0 ;
24565 int res1 = 0 ;
24566 PyObject *swig_obj[1] ;
24567
24568 if (!args) SWIG_fail;
24569 swig_obj[0] = args;
24570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24571 if (!SWIG_IsOK(res1)) {
24572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24573 }
24574 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 result = (bool)(arg1)->Iconized();
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 {
24582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24583 }
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24591 PyObject *obj;
24592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24593 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24594 return SWIG_Py_Void();
24595 }
24596
24597 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 return SWIG_Python_InitShadowInstance(args);
24599 }
24600
24601 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24602 PyObject *resultobj = 0;
24603 int arg1 = (int) 0 ;
24604 wxMaximizeEvent *result = 0 ;
24605 int val1 ;
24606 int ecode1 = 0 ;
24607 PyObject * obj0 = 0 ;
24608 char * kwnames[] = {
24609 (char *) "id", NULL
24610 };
24611
24612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24613 if (obj0) {
24614 ecode1 = SWIG_AsVal_int(obj0, &val1);
24615 if (!SWIG_IsOK(ecode1)) {
24616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24617 }
24618 arg1 = static_cast< int >(val1);
24619 }
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24623 wxPyEndAllowThreads(__tstate);
24624 if (PyErr_Occurred()) SWIG_fail;
24625 }
24626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24627 return resultobj;
24628 fail:
24629 return NULL;
24630 }
24631
24632
24633 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24634 PyObject *obj;
24635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24636 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24637 return SWIG_Py_Void();
24638 }
24639
24640 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24641 return SWIG_Python_InitShadowInstance(args);
24642 }
24643
24644 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24645 PyObject *resultobj = 0;
24646 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24647 wxPoint result;
24648 void *argp1 = 0 ;
24649 int res1 = 0 ;
24650 PyObject *swig_obj[1] ;
24651
24652 if (!args) SWIG_fail;
24653 swig_obj[0] = args;
24654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24655 if (!SWIG_IsOK(res1)) {
24656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24657 }
24658 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24659 {
24660 PyThreadState* __tstate = wxPyBeginAllowThreads();
24661 result = (arg1)->GetPosition();
24662 wxPyEndAllowThreads(__tstate);
24663 if (PyErr_Occurred()) SWIG_fail;
24664 }
24665 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 PyObject *resultobj = 0;
24674 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24675 int result;
24676 void *argp1 = 0 ;
24677 int res1 = 0 ;
24678 PyObject *swig_obj[1] ;
24679
24680 if (!args) SWIG_fail;
24681 swig_obj[0] = args;
24682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24683 if (!SWIG_IsOK(res1)) {
24684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24685 }
24686 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 result = (int)(arg1)->GetNumberOfFiles();
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 resultobj = SWIG_From_int(static_cast< int >(result));
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24701 PyObject *resultobj = 0;
24702 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24703 PyObject *result = 0 ;
24704 void *argp1 = 0 ;
24705 int res1 = 0 ;
24706 PyObject *swig_obj[1] ;
24707
24708 if (!args) SWIG_fail;
24709 swig_obj[0] = args;
24710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24711 if (!SWIG_IsOK(res1)) {
24712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24713 }
24714 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24715 {
24716 PyThreadState* __tstate = wxPyBeginAllowThreads();
24717 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 resultobj = result;
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24729 PyObject *obj;
24730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24731 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24732 return SWIG_Py_Void();
24733 }
24734
24735 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24736 PyObject *resultobj = 0;
24737 int arg1 = (int) 0 ;
24738 wxUpdateUIEvent *result = 0 ;
24739 int val1 ;
24740 int ecode1 = 0 ;
24741 PyObject * obj0 = 0 ;
24742 char * kwnames[] = {
24743 (char *) "commandId", NULL
24744 };
24745
24746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24747 if (obj0) {
24748 ecode1 = SWIG_AsVal_int(obj0, &val1);
24749 if (!SWIG_IsOK(ecode1)) {
24750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24751 }
24752 arg1 = static_cast< int >(val1);
24753 }
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24761 return resultobj;
24762 fail:
24763 return NULL;
24764 }
24765
24766
24767 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24768 PyObject *resultobj = 0;
24769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24770 bool result;
24771 void *argp1 = 0 ;
24772 int res1 = 0 ;
24773 PyObject *swig_obj[1] ;
24774
24775 if (!args) SWIG_fail;
24776 swig_obj[0] = args;
24777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24778 if (!SWIG_IsOK(res1)) {
24779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24780 }
24781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24782 {
24783 PyThreadState* __tstate = wxPyBeginAllowThreads();
24784 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24785 wxPyEndAllowThreads(__tstate);
24786 if (PyErr_Occurred()) SWIG_fail;
24787 }
24788 {
24789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24790 }
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24798 PyObject *resultobj = 0;
24799 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24800 bool result;
24801 void *argp1 = 0 ;
24802 int res1 = 0 ;
24803 PyObject *swig_obj[1] ;
24804
24805 if (!args) SWIG_fail;
24806 swig_obj[0] = args;
24807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24808 if (!SWIG_IsOK(res1)) {
24809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24810 }
24811 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24815 wxPyEndAllowThreads(__tstate);
24816 if (PyErr_Occurred()) SWIG_fail;
24817 }
24818 {
24819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24820 }
24821 return resultobj;
24822 fail:
24823 return NULL;
24824 }
24825
24826
24827 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24828 PyObject *resultobj = 0;
24829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24830 bool result;
24831 void *argp1 = 0 ;
24832 int res1 = 0 ;
24833 PyObject *swig_obj[1] ;
24834
24835 if (!args) SWIG_fail;
24836 swig_obj[0] = args;
24837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24838 if (!SWIG_IsOK(res1)) {
24839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24840 }
24841 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 {
24849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24850 }
24851 return resultobj;
24852 fail:
24853 return NULL;
24854 }
24855
24856
24857 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24858 PyObject *resultobj = 0;
24859 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24860 wxString result;
24861 void *argp1 = 0 ;
24862 int res1 = 0 ;
24863 PyObject *swig_obj[1] ;
24864
24865 if (!args) SWIG_fail;
24866 swig_obj[0] = args;
24867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24868 if (!SWIG_IsOK(res1)) {
24869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24870 }
24871 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24872 {
24873 PyThreadState* __tstate = wxPyBeginAllowThreads();
24874 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 #if wxUSE_UNICODE
24880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24881 #else
24882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24883 #endif
24884 }
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24892 PyObject *resultobj = 0;
24893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24894 bool result;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 PyObject *swig_obj[1] ;
24898
24899 if (!args) SWIG_fail;
24900 swig_obj[0] = args;
24901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24902 if (!SWIG_IsOK(res1)) {
24903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24904 }
24905 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24906 {
24907 PyThreadState* __tstate = wxPyBeginAllowThreads();
24908 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24909 wxPyEndAllowThreads(__tstate);
24910 if (PyErr_Occurred()) SWIG_fail;
24911 }
24912 {
24913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24914 }
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24922 PyObject *resultobj = 0;
24923 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24924 bool result;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 PyObject *swig_obj[1] ;
24928
24929 if (!args) SWIG_fail;
24930 swig_obj[0] = args;
24931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24932 if (!SWIG_IsOK(res1)) {
24933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24934 }
24935 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24944 }
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24952 PyObject *resultobj = 0;
24953 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24954 bool result;
24955 void *argp1 = 0 ;
24956 int res1 = 0 ;
24957 PyObject *swig_obj[1] ;
24958
24959 if (!args) SWIG_fail;
24960 swig_obj[0] = args;
24961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24962 if (!SWIG_IsOK(res1)) {
24963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24964 }
24965 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24966 {
24967 PyThreadState* __tstate = wxPyBeginAllowThreads();
24968 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24969 wxPyEndAllowThreads(__tstate);
24970 if (PyErr_Occurred()) SWIG_fail;
24971 }
24972 {
24973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24982 PyObject *resultobj = 0;
24983 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24984 bool result;
24985 void *argp1 = 0 ;
24986 int res1 = 0 ;
24987 PyObject *swig_obj[1] ;
24988
24989 if (!args) SWIG_fail;
24990 swig_obj[0] = args;
24991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24992 if (!SWIG_IsOK(res1)) {
24993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24994 }
24995 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 {
25003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25004 }
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj = 0;
25013 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25014 bool arg2 ;
25015 void *argp1 = 0 ;
25016 int res1 = 0 ;
25017 bool val2 ;
25018 int ecode2 = 0 ;
25019 PyObject * obj0 = 0 ;
25020 PyObject * obj1 = 0 ;
25021 char * kwnames[] = {
25022 (char *) "self",(char *) "check", NULL
25023 };
25024
25025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25027 if (!SWIG_IsOK(res1)) {
25028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25029 }
25030 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25032 if (!SWIG_IsOK(ecode2)) {
25033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25034 }
25035 arg2 = static_cast< bool >(val2);
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 (arg1)->Check(arg2);
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 resultobj = SWIG_Py_Void();
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj = 0;
25051 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25052 bool arg2 ;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 bool val2 ;
25056 int ecode2 = 0 ;
25057 PyObject * obj0 = 0 ;
25058 PyObject * obj1 = 0 ;
25059 char * kwnames[] = {
25060 (char *) "self",(char *) "enable", NULL
25061 };
25062
25063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25065 if (!SWIG_IsOK(res1)) {
25066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25067 }
25068 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25070 if (!SWIG_IsOK(ecode2)) {
25071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25072 }
25073 arg2 = static_cast< bool >(val2);
25074 {
25075 PyThreadState* __tstate = wxPyBeginAllowThreads();
25076 (arg1)->Enable(arg2);
25077 wxPyEndAllowThreads(__tstate);
25078 if (PyErr_Occurred()) SWIG_fail;
25079 }
25080 resultobj = SWIG_Py_Void();
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25088 PyObject *resultobj = 0;
25089 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25090 bool arg2 ;
25091 void *argp1 = 0 ;
25092 int res1 = 0 ;
25093 bool val2 ;
25094 int ecode2 = 0 ;
25095 PyObject * obj0 = 0 ;
25096 PyObject * obj1 = 0 ;
25097 char * kwnames[] = {
25098 (char *) "self",(char *) "show", NULL
25099 };
25100
25101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25103 if (!SWIG_IsOK(res1)) {
25104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25105 }
25106 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25108 if (!SWIG_IsOK(ecode2)) {
25109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25110 }
25111 arg2 = static_cast< bool >(val2);
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 (arg1)->Show(arg2);
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 resultobj = SWIG_Py_Void();
25119 return resultobj;
25120 fail:
25121 return NULL;
25122 }
25123
25124
25125 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj = 0;
25127 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25128 wxString *arg2 = 0 ;
25129 void *argp1 = 0 ;
25130 int res1 = 0 ;
25131 bool temp2 = false ;
25132 PyObject * obj0 = 0 ;
25133 PyObject * obj1 = 0 ;
25134 char * kwnames[] = {
25135 (char *) "self",(char *) "text", NULL
25136 };
25137
25138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25140 if (!SWIG_IsOK(res1)) {
25141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25142 }
25143 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25144 {
25145 arg2 = wxString_in_helper(obj1);
25146 if (arg2 == NULL) SWIG_fail;
25147 temp2 = true;
25148 }
25149 {
25150 PyThreadState* __tstate = wxPyBeginAllowThreads();
25151 (arg1)->SetText((wxString const &)*arg2);
25152 wxPyEndAllowThreads(__tstate);
25153 if (PyErr_Occurred()) SWIG_fail;
25154 }
25155 resultobj = SWIG_Py_Void();
25156 {
25157 if (temp2)
25158 delete arg2;
25159 }
25160 return resultobj;
25161 fail:
25162 {
25163 if (temp2)
25164 delete arg2;
25165 }
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj = 0;
25172 long arg1 ;
25173 long val1 ;
25174 int ecode1 = 0 ;
25175 PyObject * obj0 = 0 ;
25176 char * kwnames[] = {
25177 (char *) "updateInterval", NULL
25178 };
25179
25180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25181 ecode1 = SWIG_AsVal_long(obj0, &val1);
25182 if (!SWIG_IsOK(ecode1)) {
25183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25184 }
25185 arg1 = static_cast< long >(val1);
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 wxUpdateUIEvent::SetUpdateInterval(arg1);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_Py_Void();
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 PyObject *resultobj = 0;
25201 long result;
25202
25203 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25204 {
25205 PyThreadState* __tstate = wxPyBeginAllowThreads();
25206 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 resultobj = SWIG_From_long(static_cast< long >(result));
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj = 0;
25219 wxWindow *arg1 = (wxWindow *) 0 ;
25220 bool result;
25221 void *argp1 = 0 ;
25222 int res1 = 0 ;
25223 PyObject * obj0 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "win", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25230 if (!SWIG_IsOK(res1)) {
25231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25232 }
25233 arg1 = reinterpret_cast< wxWindow * >(argp1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 {
25241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25242 }
25243 return resultobj;
25244 fail:
25245 return NULL;
25246 }
25247
25248
25249 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25250 PyObject *resultobj = 0;
25251
25252 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 wxUpdateUIEvent::ResetUpdateTime();
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_Py_Void();
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj = 0;
25268 wxUpdateUIMode arg1 ;
25269 int val1 ;
25270 int ecode1 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 char * kwnames[] = {
25273 (char *) "mode", NULL
25274 };
25275
25276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25277 ecode1 = SWIG_AsVal_int(obj0, &val1);
25278 if (!SWIG_IsOK(ecode1)) {
25279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25280 }
25281 arg1 = static_cast< wxUpdateUIMode >(val1);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 wxUpdateUIEvent::SetMode(arg1);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_Py_Void();
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxUpdateUIMode result;
25298
25299 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 resultobj = SWIG_From_int(static_cast< int >(result));
25307 return resultobj;
25308 fail:
25309 return NULL;
25310 }
25311
25312
25313 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25314 PyObject *obj;
25315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25316 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25317 return SWIG_Py_Void();
25318 }
25319
25320 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321 return SWIG_Python_InitShadowInstance(args);
25322 }
25323
25324 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *resultobj = 0;
25326 wxSysColourChangedEvent *result = 0 ;
25327
25328 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25336 return resultobj;
25337 fail:
25338 return NULL;
25339 }
25340
25341
25342 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25343 PyObject *obj;
25344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25345 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25346 return SWIG_Py_Void();
25347 }
25348
25349 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25350 return SWIG_Python_InitShadowInstance(args);
25351 }
25352
25353 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25354 PyObject *resultobj = 0;
25355 int arg1 = (int) 0 ;
25356 wxWindow *arg2 = (wxWindow *) NULL ;
25357 wxMouseCaptureChangedEvent *result = 0 ;
25358 int val1 ;
25359 int ecode1 = 0 ;
25360 void *argp2 = 0 ;
25361 int res2 = 0 ;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 char * kwnames[] = {
25365 (char *) "winid",(char *) "gainedCapture", NULL
25366 };
25367
25368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25369 if (obj0) {
25370 ecode1 = SWIG_AsVal_int(obj0, &val1);
25371 if (!SWIG_IsOK(ecode1)) {
25372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25373 }
25374 arg1 = static_cast< int >(val1);
25375 }
25376 if (obj1) {
25377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25378 if (!SWIG_IsOK(res2)) {
25379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25380 }
25381 arg2 = reinterpret_cast< wxWindow * >(argp2);
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25397 PyObject *resultobj = 0;
25398 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25399 wxWindow *result = 0 ;
25400 void *argp1 = 0 ;
25401 int res1 = 0 ;
25402 PyObject *swig_obj[1] ;
25403
25404 if (!args) SWIG_fail;
25405 swig_obj[0] = args;
25406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25407 if (!SWIG_IsOK(res1)) {
25408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25409 }
25410 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25411 {
25412 PyThreadState* __tstate = wxPyBeginAllowThreads();
25413 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25414 wxPyEndAllowThreads(__tstate);
25415 if (PyErr_Occurred()) SWIG_fail;
25416 }
25417 {
25418 resultobj = wxPyMake_wxObject(result, (bool)0);
25419 }
25420 return resultobj;
25421 fail:
25422 return NULL;
25423 }
25424
25425
25426 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25427 PyObject *obj;
25428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25429 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25430 return SWIG_Py_Void();
25431 }
25432
25433 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 return SWIG_Python_InitShadowInstance(args);
25435 }
25436
25437 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25438 PyObject *resultobj = 0;
25439 wxDisplayChangedEvent *result = 0 ;
25440
25441 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25442 {
25443 PyThreadState* __tstate = wxPyBeginAllowThreads();
25444 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25445 wxPyEndAllowThreads(__tstate);
25446 if (PyErr_Occurred()) SWIG_fail;
25447 }
25448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 PyObject *obj;
25457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25458 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25459 return SWIG_Py_Void();
25460 }
25461
25462 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25463 return SWIG_Python_InitShadowInstance(args);
25464 }
25465
25466 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj = 0;
25468 int arg1 = (int) 0 ;
25469 wxPaletteChangedEvent *result = 0 ;
25470 int val1 ;
25471 int ecode1 = 0 ;
25472 PyObject * obj0 = 0 ;
25473 char * kwnames[] = {
25474 (char *) "id", NULL
25475 };
25476
25477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25478 if (obj0) {
25479 ecode1 = SWIG_AsVal_int(obj0, &val1);
25480 if (!SWIG_IsOK(ecode1)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25482 }
25483 arg1 = static_cast< int >(val1);
25484 }
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25499 PyObject *resultobj = 0;
25500 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25501 wxWindow *arg2 = (wxWindow *) 0 ;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 void *argp2 = 0 ;
25505 int res2 = 0 ;
25506 PyObject * obj0 = 0 ;
25507 PyObject * obj1 = 0 ;
25508 char * kwnames[] = {
25509 (char *) "self",(char *) "win", NULL
25510 };
25511
25512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25514 if (!SWIG_IsOK(res1)) {
25515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25516 }
25517 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25519 if (!SWIG_IsOK(res2)) {
25520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25521 }
25522 arg2 = reinterpret_cast< wxWindow * >(argp2);
25523 {
25524 PyThreadState* __tstate = wxPyBeginAllowThreads();
25525 (arg1)->SetChangedWindow(arg2);
25526 wxPyEndAllowThreads(__tstate);
25527 if (PyErr_Occurred()) SWIG_fail;
25528 }
25529 resultobj = SWIG_Py_Void();
25530 return resultobj;
25531 fail:
25532 return NULL;
25533 }
25534
25535
25536 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25537 PyObject *resultobj = 0;
25538 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25539 wxWindow *result = 0 ;
25540 void *argp1 = 0 ;
25541 int res1 = 0 ;
25542 PyObject *swig_obj[1] ;
25543
25544 if (!args) SWIG_fail;
25545 swig_obj[0] = args;
25546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25547 if (!SWIG_IsOK(res1)) {
25548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25549 }
25550 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 result = (wxWindow *)(arg1)->GetChangedWindow();
25554 wxPyEndAllowThreads(__tstate);
25555 if (PyErr_Occurred()) SWIG_fail;
25556 }
25557 {
25558 resultobj = wxPyMake_wxObject(result, (bool)0);
25559 }
25560 return resultobj;
25561 fail:
25562 return NULL;
25563 }
25564
25565
25566 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25567 PyObject *obj;
25568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25569 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25570 return SWIG_Py_Void();
25571 }
25572
25573 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25574 return SWIG_Python_InitShadowInstance(args);
25575 }
25576
25577 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj = 0;
25579 int arg1 = (int) 0 ;
25580 wxQueryNewPaletteEvent *result = 0 ;
25581 int val1 ;
25582 int ecode1 = 0 ;
25583 PyObject * obj0 = 0 ;
25584 char * kwnames[] = {
25585 (char *) "winid", NULL
25586 };
25587
25588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25589 if (obj0) {
25590 ecode1 = SWIG_AsVal_int(obj0, &val1);
25591 if (!SWIG_IsOK(ecode1)) {
25592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25593 }
25594 arg1 = static_cast< int >(val1);
25595 }
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject * obj0 = 0 ;
25618 PyObject * obj1 = 0 ;
25619 char * kwnames[] = {
25620 (char *) "self",(char *) "realized", NULL
25621 };
25622
25623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25625 if (!SWIG_IsOK(res1)) {
25626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25627 }
25628 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25630 if (!SWIG_IsOK(ecode2)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25632 }
25633 arg2 = static_cast< bool >(val2);
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 (arg1)->SetPaletteRealized(arg2);
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_Py_Void();
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25648 PyObject *resultobj = 0;
25649 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25650 bool result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 PyObject *swig_obj[1] ;
25654
25655 if (!args) SWIG_fail;
25656 swig_obj[0] = args;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25660 }
25661 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 {
25669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25670 }
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 PyObject *obj;
25679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25680 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25681 return SWIG_Py_Void();
25682 }
25683
25684 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 return SWIG_Python_InitShadowInstance(args);
25686 }
25687
25688 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25689 PyObject *resultobj = 0;
25690 wxNavigationKeyEvent *result = 0 ;
25691
25692 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25696 wxPyEndAllowThreads(__tstate);
25697 if (PyErr_Occurred()) SWIG_fail;
25698 }
25699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25700 return resultobj;
25701 fail:
25702 return NULL;
25703 }
25704
25705
25706 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 PyObject *resultobj = 0;
25708 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25709 bool result;
25710 void *argp1 = 0 ;
25711 int res1 = 0 ;
25712 PyObject *swig_obj[1] ;
25713
25714 if (!args) SWIG_fail;
25715 swig_obj[0] = args;
25716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25719 }
25720 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25724 wxPyEndAllowThreads(__tstate);
25725 if (PyErr_Occurred()) SWIG_fail;
25726 }
25727 {
25728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25729 }
25730 return resultobj;
25731 fail:
25732 return NULL;
25733 }
25734
25735
25736 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25737 PyObject *resultobj = 0;
25738 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25739 bool arg2 ;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 bool val2 ;
25743 int ecode2 = 0 ;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "self",(char *) "forward", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25754 }
25755 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25757 if (!SWIG_IsOK(ecode2)) {
25758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25759 }
25760 arg2 = static_cast< bool >(val2);
25761 {
25762 PyThreadState* __tstate = wxPyBeginAllowThreads();
25763 (arg1)->SetDirection(arg2);
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 resultobj = SWIG_Py_Void();
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25775 PyObject *resultobj = 0;
25776 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25777 bool result;
25778 void *argp1 = 0 ;
25779 int res1 = 0 ;
25780 PyObject *swig_obj[1] ;
25781
25782 if (!args) SWIG_fail;
25783 swig_obj[0] = args;
25784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25787 }
25788 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25792 wxPyEndAllowThreads(__tstate);
25793 if (PyErr_Occurred()) SWIG_fail;
25794 }
25795 {
25796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25797 }
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj = 0;
25806 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25807 bool arg2 ;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 bool val2 ;
25811 int ecode2 = 0 ;
25812 PyObject * obj0 = 0 ;
25813 PyObject * obj1 = 0 ;
25814 char * kwnames[] = {
25815 (char *) "self",(char *) "ischange", NULL
25816 };
25817
25818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25820 if (!SWIG_IsOK(res1)) {
25821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25822 }
25823 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25825 if (!SWIG_IsOK(ecode2)) {
25826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25827 }
25828 arg2 = static_cast< bool >(val2);
25829 {
25830 PyThreadState* __tstate = wxPyBeginAllowThreads();
25831 (arg1)->SetWindowChange(arg2);
25832 wxPyEndAllowThreads(__tstate);
25833 if (PyErr_Occurred()) SWIG_fail;
25834 }
25835 resultobj = SWIG_Py_Void();
25836 return resultobj;
25837 fail:
25838 return NULL;
25839 }
25840
25841
25842 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25843 PyObject *resultobj = 0;
25844 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25845 bool result;
25846 void *argp1 = 0 ;
25847 int res1 = 0 ;
25848 PyObject *swig_obj[1] ;
25849
25850 if (!args) SWIG_fail;
25851 swig_obj[0] = args;
25852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25853 if (!SWIG_IsOK(res1)) {
25854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25855 }
25856 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25857 {
25858 PyThreadState* __tstate = wxPyBeginAllowThreads();
25859 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25860 wxPyEndAllowThreads(__tstate);
25861 if (PyErr_Occurred()) SWIG_fail;
25862 }
25863 {
25864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25865 }
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = 0;
25874 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25875 bool arg2 ;
25876 void *argp1 = 0 ;
25877 int res1 = 0 ;
25878 bool val2 ;
25879 int ecode2 = 0 ;
25880 PyObject * obj0 = 0 ;
25881 PyObject * obj1 = 0 ;
25882 char * kwnames[] = {
25883 (char *) "self",(char *) "bIs", NULL
25884 };
25885
25886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25888 if (!SWIG_IsOK(res1)) {
25889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25890 }
25891 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25893 if (!SWIG_IsOK(ecode2)) {
25894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25895 }
25896 arg2 = static_cast< bool >(val2);
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 (arg1)->SetFromTab(arg2);
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 resultobj = SWIG_Py_Void();
25904 return resultobj;
25905 fail:
25906 return NULL;
25907 }
25908
25909
25910 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25911 PyObject *resultobj = 0;
25912 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25913 long arg2 ;
25914 void *argp1 = 0 ;
25915 int res1 = 0 ;
25916 long val2 ;
25917 int ecode2 = 0 ;
25918 PyObject * obj0 = 0 ;
25919 PyObject * obj1 = 0 ;
25920 char * kwnames[] = {
25921 (char *) "self",(char *) "flags", NULL
25922 };
25923
25924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25928 }
25929 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25930 ecode2 = SWIG_AsVal_long(obj1, &val2);
25931 if (!SWIG_IsOK(ecode2)) {
25932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25933 }
25934 arg2 = static_cast< long >(val2);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 (arg1)->SetFlags(arg2);
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 resultobj = SWIG_Py_Void();
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25949 PyObject *resultobj = 0;
25950 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25951 wxWindow *result = 0 ;
25952 void *argp1 = 0 ;
25953 int res1 = 0 ;
25954 PyObject *swig_obj[1] ;
25955
25956 if (!args) SWIG_fail;
25957 swig_obj[0] = args;
25958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25959 if (!SWIG_IsOK(res1)) {
25960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25961 }
25962 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25963 {
25964 PyThreadState* __tstate = wxPyBeginAllowThreads();
25965 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25966 wxPyEndAllowThreads(__tstate);
25967 if (PyErr_Occurred()) SWIG_fail;
25968 }
25969 {
25970 resultobj = wxPyMake_wxObject(result, (bool)0);
25971 }
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj = 0;
25980 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25981 wxWindow *arg2 = (wxWindow *) 0 ;
25982 void *argp1 = 0 ;
25983 int res1 = 0 ;
25984 void *argp2 = 0 ;
25985 int res2 = 0 ;
25986 PyObject * obj0 = 0 ;
25987 PyObject * obj1 = 0 ;
25988 char * kwnames[] = {
25989 (char *) "self",(char *) "win", NULL
25990 };
25991
25992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25994 if (!SWIG_IsOK(res1)) {
25995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25996 }
25997 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25999 if (!SWIG_IsOK(res2)) {
26000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26001 }
26002 arg2 = reinterpret_cast< wxWindow * >(argp2);
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 (arg1)->SetCurrentFocus(arg2);
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 resultobj = SWIG_Py_Void();
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26017 PyObject *obj;
26018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26019 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26020 return SWIG_Py_Void();
26021 }
26022
26023 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26024 return SWIG_Python_InitShadowInstance(args);
26025 }
26026
26027 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxWindow *arg1 = (wxWindow *) NULL ;
26030 wxWindowCreateEvent *result = 0 ;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "win", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26039 if (obj0) {
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26043 }
26044 arg1 = reinterpret_cast< wxWindow * >(argp1);
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26060 PyObject *resultobj = 0;
26061 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26062 wxWindow *result = 0 ;
26063 void *argp1 = 0 ;
26064 int res1 = 0 ;
26065 PyObject *swig_obj[1] ;
26066
26067 if (!args) SWIG_fail;
26068 swig_obj[0] = args;
26069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26070 if (!SWIG_IsOK(res1)) {
26071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26072 }
26073 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 resultobj = wxPyMake_wxObject(result, (bool)0);
26082 }
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26090 PyObject *obj;
26091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26092 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26093 return SWIG_Py_Void();
26094 }
26095
26096 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26097 return SWIG_Python_InitShadowInstance(args);
26098 }
26099
26100 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = 0;
26102 wxWindow *arg1 = (wxWindow *) NULL ;
26103 wxWindowDestroyEvent *result = 0 ;
26104 void *argp1 = 0 ;
26105 int res1 = 0 ;
26106 PyObject * obj0 = 0 ;
26107 char * kwnames[] = {
26108 (char *) "win", NULL
26109 };
26110
26111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26112 if (obj0) {
26113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26114 if (!SWIG_IsOK(res1)) {
26115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26116 }
26117 arg1 = reinterpret_cast< wxWindow * >(argp1);
26118 }
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26133 PyObject *resultobj = 0;
26134 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26135 wxWindow *result = 0 ;
26136 void *argp1 = 0 ;
26137 int res1 = 0 ;
26138 PyObject *swig_obj[1] ;
26139
26140 if (!args) SWIG_fail;
26141 swig_obj[0] = args;
26142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26145 }
26146 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26147 {
26148 PyThreadState* __tstate = wxPyBeginAllowThreads();
26149 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 {
26154 resultobj = wxPyMake_wxObject(result, (bool)0);
26155 }
26156 return resultobj;
26157 fail:
26158 return NULL;
26159 }
26160
26161
26162 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26163 PyObject *obj;
26164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26165 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26166 return SWIG_Py_Void();
26167 }
26168
26169 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26170 return SWIG_Python_InitShadowInstance(args);
26171 }
26172
26173 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj = 0;
26175 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26176 int arg2 = (int) 0 ;
26177 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26178 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26179 wxContextMenuEvent *result = 0 ;
26180 int val1 ;
26181 int ecode1 = 0 ;
26182 int val2 ;
26183 int ecode2 = 0 ;
26184 wxPoint temp3 ;
26185 PyObject * obj0 = 0 ;
26186 PyObject * obj1 = 0 ;
26187 PyObject * obj2 = 0 ;
26188 char * kwnames[] = {
26189 (char *) "type",(char *) "winid",(char *) "pt", NULL
26190 };
26191
26192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26193 if (obj0) {
26194 ecode1 = SWIG_AsVal_int(obj0, &val1);
26195 if (!SWIG_IsOK(ecode1)) {
26196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26197 }
26198 arg1 = static_cast< wxEventType >(val1);
26199 }
26200 if (obj1) {
26201 ecode2 = SWIG_AsVal_int(obj1, &val2);
26202 if (!SWIG_IsOK(ecode2)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26204 }
26205 arg2 = static_cast< int >(val2);
26206 }
26207 if (obj2) {
26208 {
26209 arg3 = &temp3;
26210 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26211 }
26212 }
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26227 PyObject *resultobj = 0;
26228 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26229 wxPoint *result = 0 ;
26230 void *argp1 = 0 ;
26231 int res1 = 0 ;
26232 PyObject *swig_obj[1] ;
26233
26234 if (!args) SWIG_fail;
26235 swig_obj[0] = args;
26236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26237 if (!SWIG_IsOK(res1)) {
26238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26239 }
26240 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26241 {
26242 PyThreadState* __tstate = wxPyBeginAllowThreads();
26243 {
26244 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26245 result = (wxPoint *) &_result_ref;
26246 }
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26258 PyObject *resultobj = 0;
26259 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26260 wxPoint *arg2 = 0 ;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 wxPoint temp2 ;
26264 PyObject * obj0 = 0 ;
26265 PyObject * obj1 = 0 ;
26266 char * kwnames[] = {
26267 (char *) "self",(char *) "pos", NULL
26268 };
26269
26270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26274 }
26275 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26276 {
26277 arg2 = &temp2;
26278 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26279 }
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 (arg1)->SetPosition((wxPoint const &)*arg2);
26283 wxPyEndAllowThreads(__tstate);
26284 if (PyErr_Occurred()) SWIG_fail;
26285 }
26286 resultobj = SWIG_Py_Void();
26287 return resultobj;
26288 fail:
26289 return NULL;
26290 }
26291
26292
26293 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26294 PyObject *obj;
26295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26296 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26297 return SWIG_Py_Void();
26298 }
26299
26300 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26301 return SWIG_Python_InitShadowInstance(args);
26302 }
26303
26304 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *resultobj = 0;
26306 wxIdleEvent *result = 0 ;
26307
26308 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26309 {
26310 PyThreadState* __tstate = wxPyBeginAllowThreads();
26311 result = (wxIdleEvent *)new wxIdleEvent();
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj = 0;
26324 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26325 bool arg2 = (bool) true ;
26326 void *argp1 = 0 ;
26327 int res1 = 0 ;
26328 bool val2 ;
26329 int ecode2 = 0 ;
26330 PyObject * obj0 = 0 ;
26331 PyObject * obj1 = 0 ;
26332 char * kwnames[] = {
26333 (char *) "self",(char *) "needMore", NULL
26334 };
26335
26336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26338 if (!SWIG_IsOK(res1)) {
26339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26340 }
26341 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26342 if (obj1) {
26343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26344 if (!SWIG_IsOK(ecode2)) {
26345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26346 }
26347 arg2 = static_cast< bool >(val2);
26348 }
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 (arg1)->RequestMore(arg2);
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_Py_Void();
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *resultobj = 0;
26364 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26365 bool result;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 PyObject *swig_obj[1] ;
26369
26370 if (!args) SWIG_fail;
26371 swig_obj[0] = args;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26375 }
26376 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 {
26384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26385 }
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26393 PyObject *resultobj = 0;
26394 wxIdleMode arg1 ;
26395 int val1 ;
26396 int ecode1 = 0 ;
26397 PyObject * obj0 = 0 ;
26398 char * kwnames[] = {
26399 (char *) "mode", NULL
26400 };
26401
26402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26403 ecode1 = SWIG_AsVal_int(obj0, &val1);
26404 if (!SWIG_IsOK(ecode1)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26406 }
26407 arg1 = static_cast< wxIdleMode >(val1);
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 wxIdleEvent::SetMode(arg1);
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 resultobj = SWIG_Py_Void();
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *resultobj = 0;
26423 wxIdleMode result;
26424
26425 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26426 {
26427 PyThreadState* __tstate = wxPyBeginAllowThreads();
26428 result = (wxIdleMode)wxIdleEvent::GetMode();
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 resultobj = SWIG_From_int(static_cast< int >(result));
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj = 0;
26441 wxWindow *arg1 = (wxWindow *) 0 ;
26442 bool result;
26443 void *argp1 = 0 ;
26444 int res1 = 0 ;
26445 PyObject * obj0 = 0 ;
26446 char * kwnames[] = {
26447 (char *) "win", NULL
26448 };
26449
26450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26452 if (!SWIG_IsOK(res1)) {
26453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26454 }
26455 arg1 = reinterpret_cast< wxWindow * >(argp1);
26456 {
26457 PyThreadState* __tstate = wxPyBeginAllowThreads();
26458 result = (bool)wxIdleEvent::CanSend(arg1);
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 {
26463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26464 }
26465 return resultobj;
26466 fail:
26467 return NULL;
26468 }
26469
26470
26471 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26472 PyObject *obj;
26473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26474 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26475 return SWIG_Py_Void();
26476 }
26477
26478 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 return SWIG_Python_InitShadowInstance(args);
26480 }
26481
26482 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26483 PyObject *resultobj = 0;
26484 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26485 int arg2 = (int) 0 ;
26486 wxClipboardTextEvent *result = 0 ;
26487 int val1 ;
26488 int ecode1 = 0 ;
26489 int val2 ;
26490 int ecode2 = 0 ;
26491 PyObject * obj0 = 0 ;
26492 PyObject * obj1 = 0 ;
26493 char * kwnames[] = {
26494 (char *) "type",(char *) "winid", NULL
26495 };
26496
26497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26498 if (obj0) {
26499 ecode1 = SWIG_AsVal_int(obj0, &val1);
26500 if (!SWIG_IsOK(ecode1)) {
26501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26502 }
26503 arg1 = static_cast< wxEventType >(val1);
26504 }
26505 if (obj1) {
26506 ecode2 = SWIG_AsVal_int(obj1, &val2);
26507 if (!SWIG_IsOK(ecode2)) {
26508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26509 }
26510 arg2 = static_cast< int >(val2);
26511 }
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26526 PyObject *obj;
26527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26528 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26529 return SWIG_Py_Void();
26530 }
26531
26532 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 return SWIG_Python_InitShadowInstance(args);
26534 }
26535
26536 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26537 PyObject *resultobj = 0;
26538 int arg1 = (int) 0 ;
26539 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26540 wxPyEvent *result = 0 ;
26541 int val1 ;
26542 int ecode1 = 0 ;
26543 int val2 ;
26544 int ecode2 = 0 ;
26545 PyObject * obj0 = 0 ;
26546 PyObject * obj1 = 0 ;
26547 char * kwnames[] = {
26548 (char *) "winid",(char *) "eventType", NULL
26549 };
26550
26551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26552 if (obj0) {
26553 ecode1 = SWIG_AsVal_int(obj0, &val1);
26554 if (!SWIG_IsOK(ecode1)) {
26555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26556 }
26557 arg1 = static_cast< int >(val1);
26558 }
26559 if (obj1) {
26560 ecode2 = SWIG_AsVal_int(obj1, &val2);
26561 if (!SWIG_IsOK(ecode2)) {
26562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26563 }
26564 arg2 = static_cast< wxEventType >(val2);
26565 }
26566 {
26567 PyThreadState* __tstate = wxPyBeginAllowThreads();
26568 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26580 PyObject *resultobj = 0;
26581 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26582 void *argp1 = 0 ;
26583 int res1 = 0 ;
26584 PyObject *swig_obj[1] ;
26585
26586 if (!args) SWIG_fail;
26587 swig_obj[0] = args;
26588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26589 if (!SWIG_IsOK(res1)) {
26590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26591 }
26592 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 delete arg1;
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = SWIG_Py_Void();
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj = 0;
26609 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26610 PyObject *arg2 = (PyObject *) 0 ;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 PyObject * obj0 = 0 ;
26614 PyObject * obj1 = 0 ;
26615 char * kwnames[] = {
26616 (char *) "self",(char *) "self", NULL
26617 };
26618
26619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26621 if (!SWIG_IsOK(res1)) {
26622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26623 }
26624 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26625 arg2 = obj1;
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->SetSelf(arg2);
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_Py_Void();
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26640 PyObject *resultobj = 0;
26641 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26642 PyObject *result = 0 ;
26643 void *argp1 = 0 ;
26644 int res1 = 0 ;
26645 PyObject *swig_obj[1] ;
26646
26647 if (!args) SWIG_fail;
26648 swig_obj[0] = args;
26649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26650 if (!SWIG_IsOK(res1)) {
26651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26652 }
26653 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26654 {
26655 PyThreadState* __tstate = wxPyBeginAllowThreads();
26656 result = (PyObject *)(arg1)->GetSelf();
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 resultobj = result;
26661 return resultobj;
26662 fail:
26663 return NULL;
26664 }
26665
26666
26667 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26668 PyObject *obj;
26669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26671 return SWIG_Py_Void();
26672 }
26673
26674 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26675 return SWIG_Python_InitShadowInstance(args);
26676 }
26677
26678 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26679 PyObject *resultobj = 0;
26680 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26681 int arg2 = (int) 0 ;
26682 wxPyCommandEvent *result = 0 ;
26683 int val1 ;
26684 int ecode1 = 0 ;
26685 int val2 ;
26686 int ecode2 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 PyObject * obj1 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "eventType",(char *) "id", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26694 if (obj0) {
26695 ecode1 = SWIG_AsVal_int(obj0, &val1);
26696 if (!SWIG_IsOK(ecode1)) {
26697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26698 }
26699 arg1 = static_cast< wxEventType >(val1);
26700 }
26701 if (obj1) {
26702 ecode2 = SWIG_AsVal_int(obj1, &val2);
26703 if (!SWIG_IsOK(ecode2)) {
26704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26705 }
26706 arg2 = static_cast< int >(val2);
26707 }
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 PyObject *resultobj = 0;
26723 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 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_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26731 if (!SWIG_IsOK(res1)) {
26732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26733 }
26734 arg1 = reinterpret_cast< wxPyCommandEvent * >(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_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26752 PyObject *arg2 = (PyObject *) 0 ;
26753 void *argp1 = 0 ;
26754 int res1 = 0 ;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757 char * kwnames[] = {
26758 (char *) "self",(char *) "self", NULL
26759 };
26760
26761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26765 }
26766 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26767 arg2 = obj1;
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 (arg1)->SetSelf(arg2);
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 resultobj = SWIG_Py_Void();
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *resultobj = 0;
26783 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26784 PyObject *result = 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject *swig_obj[1] ;
26788
26789 if (!args) SWIG_fail;
26790 swig_obj[0] = args;
26791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26792 if (!SWIG_IsOK(res1)) {
26793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26794 }
26795 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (PyObject *)(arg1)->GetSelf();
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 resultobj = result;
26803 return resultobj;
26804 fail:
26805 return NULL;
26806 }
26807
26808
26809 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26810 PyObject *obj;
26811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26812 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26813 return SWIG_Py_Void();
26814 }
26815
26816 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26817 return SWIG_Python_InitShadowInstance(args);
26818 }
26819
26820 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj = 0;
26822 wxWindow *arg1 = (wxWindow *) 0 ;
26823 wxDateTime *arg2 = 0 ;
26824 wxEventType arg3 ;
26825 wxDateEvent *result = 0 ;
26826 void *argp1 = 0 ;
26827 int res1 = 0 ;
26828 void *argp2 = 0 ;
26829 int res2 = 0 ;
26830 int val3 ;
26831 int ecode3 = 0 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 PyObject * obj2 = 0 ;
26835 char * kwnames[] = {
26836 (char *) "win",(char *) "dt",(char *) "type", NULL
26837 };
26838
26839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26841 if (!SWIG_IsOK(res1)) {
26842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26843 }
26844 arg1 = reinterpret_cast< wxWindow * >(argp1);
26845 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26846 if (!SWIG_IsOK(res2)) {
26847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26848 }
26849 if (!argp2) {
26850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26851 }
26852 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26853 ecode3 = SWIG_AsVal_int(obj2, &val3);
26854 if (!SWIG_IsOK(ecode3)) {
26855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26856 }
26857 arg3 = static_cast< wxEventType >(val3);
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26874 wxDateTime *result = 0 ;
26875 void *argp1 = 0 ;
26876 int res1 = 0 ;
26877 PyObject *swig_obj[1] ;
26878
26879 if (!args) SWIG_fail;
26880 swig_obj[0] = args;
26881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26884 }
26885 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 {
26889 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26890 result = (wxDateTime *) &_result_ref;
26891 }
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26896 return resultobj;
26897 fail:
26898 return NULL;
26899 }
26900
26901
26902 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = 0;
26904 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26905 wxDateTime *arg2 = 0 ;
26906 void *argp1 = 0 ;
26907 int res1 = 0 ;
26908 void *argp2 = 0 ;
26909 int res2 = 0 ;
26910 PyObject * obj0 = 0 ;
26911 PyObject * obj1 = 0 ;
26912 char * kwnames[] = {
26913 (char *) "self",(char *) "date", NULL
26914 };
26915
26916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26918 if (!SWIG_IsOK(res1)) {
26919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26920 }
26921 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26923 if (!SWIG_IsOK(res2)) {
26924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26925 }
26926 if (!argp2) {
26927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26928 }
26929 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->SetDate((wxDateTime const &)*arg2);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_Py_Void();
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26944 PyObject *obj;
26945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26946 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26947 return SWIG_Py_Void();
26948 }
26949
26950 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26951 return SWIG_Python_InitShadowInstance(args);
26952 }
26953
26954 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26955 PyObject *resultobj = 0;
26956 wxPyApp *result = 0 ;
26957
26958 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (wxPyApp *)new_wxPyApp();
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26973 PyObject *resultobj = 0;
26974 wxPyApp *arg1 = (wxPyApp *) 0 ;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 PyObject *swig_obj[1] ;
26978
26979 if (!args) SWIG_fail;
26980 swig_obj[0] = args;
26981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26982 if (!SWIG_IsOK(res1)) {
26983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26984 }
26985 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 delete arg1;
26989
26990 wxPyEndAllowThreads(__tstate);
26991 if (PyErr_Occurred()) SWIG_fail;
26992 }
26993 resultobj = SWIG_Py_Void();
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxPyApp *arg1 = (wxPyApp *) 0 ;
27003 PyObject *arg2 = (PyObject *) 0 ;
27004 PyObject *arg3 = (PyObject *) 0 ;
27005 bool arg4 ;
27006 void *argp1 = 0 ;
27007 int res1 = 0 ;
27008 bool val4 ;
27009 int ecode4 = 0 ;
27010 PyObject * obj0 = 0 ;
27011 PyObject * obj1 = 0 ;
27012 PyObject * obj2 = 0 ;
27013 PyObject * obj3 = 0 ;
27014 char * kwnames[] = {
27015 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27016 };
27017
27018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27020 if (!SWIG_IsOK(res1)) {
27021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27022 }
27023 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27024 arg2 = obj1;
27025 arg3 = obj2;
27026 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27027 if (!SWIG_IsOK(ecode4)) {
27028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27029 }
27030 arg4 = static_cast< bool >(val4);
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27034 wxPyEndAllowThreads(__tstate);
27035 if (PyErr_Occurred()) SWIG_fail;
27036 }
27037 resultobj = SWIG_Py_Void();
27038 return resultobj;
27039 fail:
27040 return NULL;
27041 }
27042
27043
27044 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27045 PyObject *resultobj = 0;
27046 wxPyApp *arg1 = (wxPyApp *) 0 ;
27047 wxString result;
27048 void *argp1 = 0 ;
27049 int res1 = 0 ;
27050 PyObject *swig_obj[1] ;
27051
27052 if (!args) SWIG_fail;
27053 swig_obj[0] = args;
27054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27055 if (!SWIG_IsOK(res1)) {
27056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27057 }
27058 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27059 {
27060 PyThreadState* __tstate = wxPyBeginAllowThreads();
27061 result = ((wxPyApp const *)arg1)->GetAppName();
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 {
27066 #if wxUSE_UNICODE
27067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27068 #else
27069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27070 #endif
27071 }
27072 return resultobj;
27073 fail:
27074 return NULL;
27075 }
27076
27077
27078 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27079 PyObject *resultobj = 0;
27080 wxPyApp *arg1 = (wxPyApp *) 0 ;
27081 wxString *arg2 = 0 ;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 bool temp2 = false ;
27085 PyObject * obj0 = 0 ;
27086 PyObject * obj1 = 0 ;
27087 char * kwnames[] = {
27088 (char *) "self",(char *) "name", NULL
27089 };
27090
27091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27093 if (!SWIG_IsOK(res1)) {
27094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27095 }
27096 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27097 {
27098 arg2 = wxString_in_helper(obj1);
27099 if (arg2 == NULL) SWIG_fail;
27100 temp2 = true;
27101 }
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 (arg1)->SetAppName((wxString const &)*arg2);
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 resultobj = SWIG_Py_Void();
27109 {
27110 if (temp2)
27111 delete arg2;
27112 }
27113 return resultobj;
27114 fail:
27115 {
27116 if (temp2)
27117 delete arg2;
27118 }
27119 return NULL;
27120 }
27121
27122
27123 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27124 PyObject *resultobj = 0;
27125 wxPyApp *arg1 = (wxPyApp *) 0 ;
27126 wxString result;
27127 void *argp1 = 0 ;
27128 int res1 = 0 ;
27129 PyObject *swig_obj[1] ;
27130
27131 if (!args) SWIG_fail;
27132 swig_obj[0] = args;
27133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27134 if (!SWIG_IsOK(res1)) {
27135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27136 }
27137 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27138 {
27139 PyThreadState* __tstate = wxPyBeginAllowThreads();
27140 result = ((wxPyApp const *)arg1)->GetClassName();
27141 wxPyEndAllowThreads(__tstate);
27142 if (PyErr_Occurred()) SWIG_fail;
27143 }
27144 {
27145 #if wxUSE_UNICODE
27146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27147 #else
27148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27149 #endif
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj = 0;
27159 wxPyApp *arg1 = (wxPyApp *) 0 ;
27160 wxString *arg2 = 0 ;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 bool temp2 = false ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char * kwnames[] = {
27167 (char *) "self",(char *) "name", NULL
27168 };
27169
27170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27172 if (!SWIG_IsOK(res1)) {
27173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27174 }
27175 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27176 {
27177 arg2 = wxString_in_helper(obj1);
27178 if (arg2 == NULL) SWIG_fail;
27179 temp2 = true;
27180 }
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 (arg1)->SetClassName((wxString const &)*arg2);
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 resultobj = SWIG_Py_Void();
27188 {
27189 if (temp2)
27190 delete arg2;
27191 }
27192 return resultobj;
27193 fail:
27194 {
27195 if (temp2)
27196 delete arg2;
27197 }
27198 return NULL;
27199 }
27200
27201
27202 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27203 PyObject *resultobj = 0;
27204 wxPyApp *arg1 = (wxPyApp *) 0 ;
27205 wxString *result = 0 ;
27206 void *argp1 = 0 ;
27207 int res1 = 0 ;
27208 PyObject *swig_obj[1] ;
27209
27210 if (!args) SWIG_fail;
27211 swig_obj[0] = args;
27212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27215 }
27216 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 {
27220 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27221 result = (wxString *) &_result_ref;
27222 }
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 {
27227 #if wxUSE_UNICODE
27228 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27229 #else
27230 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27231 #endif
27232 }
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj = 0;
27241 wxPyApp *arg1 = (wxPyApp *) 0 ;
27242 wxString *arg2 = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 bool temp2 = false ;
27246 PyObject * obj0 = 0 ;
27247 PyObject * obj1 = 0 ;
27248 char * kwnames[] = {
27249 (char *) "self",(char *) "name", NULL
27250 };
27251
27252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27254 if (!SWIG_IsOK(res1)) {
27255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27256 }
27257 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27258 {
27259 arg2 = wxString_in_helper(obj1);
27260 if (arg2 == NULL) SWIG_fail;
27261 temp2 = true;
27262 }
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 (arg1)->SetVendorName((wxString const &)*arg2);
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 resultobj = SWIG_Py_Void();
27270 {
27271 if (temp2)
27272 delete arg2;
27273 }
27274 return resultobj;
27275 fail:
27276 {
27277 if (temp2)
27278 delete arg2;
27279 }
27280 return NULL;
27281 }
27282
27283
27284 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27285 PyObject *resultobj = 0;
27286 wxPyApp *arg1 = (wxPyApp *) 0 ;
27287 wxAppTraits *result = 0 ;
27288 void *argp1 = 0 ;
27289 int res1 = 0 ;
27290 PyObject *swig_obj[1] ;
27291
27292 if (!args) SWIG_fail;
27293 swig_obj[0] = args;
27294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27295 if (!SWIG_IsOK(res1)) {
27296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27297 }
27298 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27299 {
27300 PyThreadState* __tstate = wxPyBeginAllowThreads();
27301 result = (wxAppTraits *)(arg1)->GetTraits();
27302 wxPyEndAllowThreads(__tstate);
27303 if (PyErr_Occurred()) SWIG_fail;
27304 }
27305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27306 return resultobj;
27307 fail:
27308 return NULL;
27309 }
27310
27311
27312 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27313 PyObject *resultobj = 0;
27314 wxPyApp *arg1 = (wxPyApp *) 0 ;
27315 void *argp1 = 0 ;
27316 int res1 = 0 ;
27317 PyObject *swig_obj[1] ;
27318
27319 if (!args) SWIG_fail;
27320 swig_obj[0] = args;
27321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27322 if (!SWIG_IsOK(res1)) {
27323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27324 }
27325 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 (arg1)->ProcessPendingEvents();
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 resultobj = SWIG_Py_Void();
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj = 0;
27341 wxPyApp *arg1 = (wxPyApp *) 0 ;
27342 bool arg2 = (bool) false ;
27343 bool result;
27344 void *argp1 = 0 ;
27345 int res1 = 0 ;
27346 bool val2 ;
27347 int ecode2 = 0 ;
27348 PyObject * obj0 = 0 ;
27349 PyObject * obj1 = 0 ;
27350 char * kwnames[] = {
27351 (char *) "self",(char *) "onlyIfNeeded", NULL
27352 };
27353
27354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27356 if (!SWIG_IsOK(res1)) {
27357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27358 }
27359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27360 if (obj1) {
27361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27362 if (!SWIG_IsOK(ecode2)) {
27363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27364 }
27365 arg2 = static_cast< bool >(val2);
27366 }
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = (bool)(arg1)->Yield(arg2);
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxPyApp *arg1 = (wxPyApp *) 0 ;
27385 void *argp1 = 0 ;
27386 int res1 = 0 ;
27387 PyObject *swig_obj[1] ;
27388
27389 if (!args) SWIG_fail;
27390 swig_obj[0] = args;
27391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27392 if (!SWIG_IsOK(res1)) {
27393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27394 }
27395 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 (arg1)->WakeUpIdle();
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_Py_Void();
27403 return resultobj;
27404 fail:
27405 return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27410 PyObject *resultobj = 0;
27411 bool result;
27412
27413 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (bool)wxPyApp::IsMainLoopRunning();
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 {
27421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27422 }
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxPyApp *arg1 = (wxPyApp *) 0 ;
27432 int result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 PyObject *swig_obj[1] ;
27436
27437 if (!args) SWIG_fail;
27438 swig_obj[0] = args;
27439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27440 if (!SWIG_IsOK(res1)) {
27441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27442 }
27443 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (int)(arg1)->MainLoop();
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 resultobj = SWIG_From_int(static_cast< int >(result));
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27458 PyObject *resultobj = 0;
27459 wxPyApp *arg1 = (wxPyApp *) 0 ;
27460 void *argp1 = 0 ;
27461 int res1 = 0 ;
27462 PyObject *swig_obj[1] ;
27463
27464 if (!args) SWIG_fail;
27465 swig_obj[0] = args;
27466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27467 if (!SWIG_IsOK(res1)) {
27468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27469 }
27470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 (arg1)->Exit();
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = SWIG_Py_Void();
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27485 PyObject *resultobj = 0;
27486 wxPyApp *arg1 = (wxPyApp *) 0 ;
27487 void *argp1 = 0 ;
27488 int res1 = 0 ;
27489 PyObject *swig_obj[1] ;
27490
27491 if (!args) SWIG_fail;
27492 swig_obj[0] = args;
27493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27494 if (!SWIG_IsOK(res1)) {
27495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27496 }
27497 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 (arg1)->ExitMainLoop();
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 resultobj = SWIG_Py_Void();
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27512 PyObject *resultobj = 0;
27513 wxPyApp *arg1 = (wxPyApp *) 0 ;
27514 bool result;
27515 void *argp1 = 0 ;
27516 int res1 = 0 ;
27517 PyObject *swig_obj[1] ;
27518
27519 if (!args) SWIG_fail;
27520 swig_obj[0] = args;
27521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27522 if (!SWIG_IsOK(res1)) {
27523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27524 }
27525 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27526 {
27527 PyThreadState* __tstate = wxPyBeginAllowThreads();
27528 result = (bool)(arg1)->Pending();
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 {
27533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27534 }
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *resultobj = 0;
27543 wxPyApp *arg1 = (wxPyApp *) 0 ;
27544 bool result;
27545 void *argp1 = 0 ;
27546 int res1 = 0 ;
27547 PyObject *swig_obj[1] ;
27548
27549 if (!args) SWIG_fail;
27550 swig_obj[0] = args;
27551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27552 if (!SWIG_IsOK(res1)) {
27553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27554 }
27555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (bool)(arg1)->Dispatch();
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27572 PyObject *resultobj = 0;
27573 wxPyApp *arg1 = (wxPyApp *) 0 ;
27574 bool result;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 PyObject *swig_obj[1] ;
27578
27579 if (!args) SWIG_fail;
27580 swig_obj[0] = args;
27581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27582 if (!SWIG_IsOK(res1)) {
27583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27584 }
27585 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 result = (bool)(arg1)->ProcessIdle();
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 {
27593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27594 }
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27602 PyObject *resultobj = 0;
27603 wxPyApp *arg1 = (wxPyApp *) 0 ;
27604 wxWindow *arg2 = (wxWindow *) 0 ;
27605 wxIdleEvent *arg3 = 0 ;
27606 bool result;
27607 void *argp1 = 0 ;
27608 int res1 = 0 ;
27609 void *argp2 = 0 ;
27610 int res2 = 0 ;
27611 void *argp3 = 0 ;
27612 int res3 = 0 ;
27613 PyObject * obj0 = 0 ;
27614 PyObject * obj1 = 0 ;
27615 PyObject * obj2 = 0 ;
27616 char * kwnames[] = {
27617 (char *) "self",(char *) "win",(char *) "event", NULL
27618 };
27619
27620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27624 }
27625 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27627 if (!SWIG_IsOK(res2)) {
27628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27629 }
27630 arg2 = reinterpret_cast< wxWindow * >(argp2);
27631 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27632 if (!SWIG_IsOK(res3)) {
27633 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27634 }
27635 if (!argp3) {
27636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27637 }
27638 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27639 {
27640 PyThreadState* __tstate = wxPyBeginAllowThreads();
27641 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 {
27646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27647 }
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxPyApp *arg1 = (wxPyApp *) 0 ;
27657 bool result;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27667 }
27668 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (bool)((wxPyApp const *)arg1)->IsActive();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 {
27676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27677 }
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27685 PyObject *resultobj = 0;
27686 wxPyApp *arg1 = (wxPyApp *) 0 ;
27687 wxWindow *arg2 = (wxWindow *) 0 ;
27688 void *argp1 = 0 ;
27689 int res1 = 0 ;
27690 void *argp2 = 0 ;
27691 int res2 = 0 ;
27692 PyObject * obj0 = 0 ;
27693 PyObject * obj1 = 0 ;
27694 char * kwnames[] = {
27695 (char *) "self",(char *) "win", NULL
27696 };
27697
27698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27700 if (!SWIG_IsOK(res1)) {
27701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27702 }
27703 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27705 if (!SWIG_IsOK(res2)) {
27706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27707 }
27708 arg2 = reinterpret_cast< wxWindow * >(argp2);
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 (arg1)->SetTopWindow(arg2);
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = SWIG_Py_Void();
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *resultobj = 0;
27724 wxPyApp *arg1 = (wxPyApp *) 0 ;
27725 wxWindow *result = 0 ;
27726 void *argp1 = 0 ;
27727 int res1 = 0 ;
27728 PyObject *swig_obj[1] ;
27729
27730 if (!args) SWIG_fail;
27731 swig_obj[0] = args;
27732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27735 }
27736 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = wxPyMake_wxObject(result, (bool)0);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj = 0;
27754 wxPyApp *arg1 = (wxPyApp *) 0 ;
27755 bool arg2 ;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 bool val2 ;
27759 int ecode2 = 0 ;
27760 PyObject * obj0 = 0 ;
27761 PyObject * obj1 = 0 ;
27762 char * kwnames[] = {
27763 (char *) "self",(char *) "flag", NULL
27764 };
27765
27766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27768 if (!SWIG_IsOK(res1)) {
27769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27770 }
27771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27773 if (!SWIG_IsOK(ecode2)) {
27774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27775 }
27776 arg2 = static_cast< bool >(val2);
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 (arg1)->SetExitOnFrameDelete(arg2);
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 resultobj = SWIG_Py_Void();
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27791 PyObject *resultobj = 0;
27792 wxPyApp *arg1 = (wxPyApp *) 0 ;
27793 bool result;
27794 void *argp1 = 0 ;
27795 int res1 = 0 ;
27796 PyObject *swig_obj[1] ;
27797
27798 if (!args) SWIG_fail;
27799 swig_obj[0] = args;
27800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27801 if (!SWIG_IsOK(res1)) {
27802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27803 }
27804 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 {
27812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27813 }
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27821 PyObject *resultobj = 0;
27822 wxPyApp *arg1 = (wxPyApp *) 0 ;
27823 bool arg2 ;
27824 void *argp1 = 0 ;
27825 int res1 = 0 ;
27826 bool val2 ;
27827 int ecode2 = 0 ;
27828 PyObject * obj0 = 0 ;
27829 PyObject * obj1 = 0 ;
27830 char * kwnames[] = {
27831 (char *) "self",(char *) "flag", NULL
27832 };
27833
27834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27836 if (!SWIG_IsOK(res1)) {
27837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27838 }
27839 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27841 if (!SWIG_IsOK(ecode2)) {
27842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27843 }
27844 arg2 = static_cast< bool >(val2);
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 (arg1)->SetUseBestVisual(arg2);
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 resultobj = SWIG_Py_Void();
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27859 PyObject *resultobj = 0;
27860 wxPyApp *arg1 = (wxPyApp *) 0 ;
27861 bool result;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 PyObject *swig_obj[1] ;
27865
27866 if (!args) SWIG_fail;
27867 swig_obj[0] = args;
27868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27871 }
27872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 {
27880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27881 }
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj = 0;
27890 wxPyApp *arg1 = (wxPyApp *) 0 ;
27891 int arg2 ;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 int val2 ;
27895 int ecode2 = 0 ;
27896 PyObject * obj0 = 0 ;
27897 PyObject * obj1 = 0 ;
27898 char * kwnames[] = {
27899 (char *) "self",(char *) "mode", NULL
27900 };
27901
27902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27904 if (!SWIG_IsOK(res1)) {
27905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27906 }
27907 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27908 ecode2 = SWIG_AsVal_int(obj1, &val2);
27909 if (!SWIG_IsOK(ecode2)) {
27910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27911 }
27912 arg2 = static_cast< int >(val2);
27913 {
27914 PyThreadState* __tstate = wxPyBeginAllowThreads();
27915 (arg1)->SetPrintMode(arg2);
27916 wxPyEndAllowThreads(__tstate);
27917 if (PyErr_Occurred()) SWIG_fail;
27918 }
27919 resultobj = SWIG_Py_Void();
27920 return resultobj;
27921 fail:
27922 return NULL;
27923 }
27924
27925
27926 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27927 PyObject *resultobj = 0;
27928 wxPyApp *arg1 = (wxPyApp *) 0 ;
27929 int result;
27930 void *argp1 = 0 ;
27931 int res1 = 0 ;
27932 PyObject *swig_obj[1] ;
27933
27934 if (!args) SWIG_fail;
27935 swig_obj[0] = args;
27936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27939 }
27940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_From_int(static_cast< int >(result));
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj = 0;
27956 wxPyApp *arg1 = (wxPyApp *) 0 ;
27957 int arg2 ;
27958 void *argp1 = 0 ;
27959 int res1 = 0 ;
27960 int val2 ;
27961 int ecode2 = 0 ;
27962 PyObject * obj0 = 0 ;
27963 PyObject * obj1 = 0 ;
27964 char * kwnames[] = {
27965 (char *) "self",(char *) "mode", NULL
27966 };
27967
27968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27970 if (!SWIG_IsOK(res1)) {
27971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27972 }
27973 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27974 ecode2 = SWIG_AsVal_int(obj1, &val2);
27975 if (!SWIG_IsOK(ecode2)) {
27976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27977 }
27978 arg2 = static_cast< int >(val2);
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 (arg1)->SetAssertMode(arg2);
27982 wxPyEndAllowThreads(__tstate);
27983 if (PyErr_Occurred()) SWIG_fail;
27984 }
27985 resultobj = SWIG_Py_Void();
27986 return resultobj;
27987 fail:
27988 return NULL;
27989 }
27990
27991
27992 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27993 PyObject *resultobj = 0;
27994 wxPyApp *arg1 = (wxPyApp *) 0 ;
27995 int result;
27996 void *argp1 = 0 ;
27997 int res1 = 0 ;
27998 PyObject *swig_obj[1] ;
27999
28000 if (!args) SWIG_fail;
28001 swig_obj[0] = args;
28002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28003 if (!SWIG_IsOK(res1)) {
28004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28005 }
28006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 result = (int)(arg1)->GetAssertMode();
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_From_int(static_cast< int >(result));
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28021 PyObject *resultobj = 0;
28022 bool result;
28023
28024 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 {
28032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28033 }
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28041 PyObject *resultobj = 0;
28042 long result;
28043
28044 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 result = (long)wxPyApp::GetMacAboutMenuItemId();
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_From_long(static_cast< long >(result));
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28059 PyObject *resultobj = 0;
28060 long result;
28061
28062 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28063 {
28064 PyThreadState* __tstate = wxPyBeginAllowThreads();
28065 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28066 wxPyEndAllowThreads(__tstate);
28067 if (PyErr_Occurred()) SWIG_fail;
28068 }
28069 resultobj = SWIG_From_long(static_cast< long >(result));
28070 return resultobj;
28071 fail:
28072 return NULL;
28073 }
28074
28075
28076 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28077 PyObject *resultobj = 0;
28078 long result;
28079
28080 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 result = (long)wxPyApp::GetMacExitMenuItemId();
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_From_long(static_cast< long >(result));
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 wxString result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = wxPyApp::GetMacHelpMenuTitleName();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 {
28106 #if wxUSE_UNICODE
28107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28108 #else
28109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28110 #endif
28111 }
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj = 0;
28120 bool arg1 ;
28121 bool val1 ;
28122 int ecode1 = 0 ;
28123 PyObject * obj0 = 0 ;
28124 char * kwnames[] = {
28125 (char *) "val", NULL
28126 };
28127
28128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28129 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28130 if (!SWIG_IsOK(ecode1)) {
28131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28132 }
28133 arg1 = static_cast< bool >(val1);
28134 {
28135 PyThreadState* __tstate = wxPyBeginAllowThreads();
28136 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 resultobj = SWIG_Py_Void();
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj = 0;
28149 long arg1 ;
28150 long val1 ;
28151 int ecode1 = 0 ;
28152 PyObject * obj0 = 0 ;
28153 char * kwnames[] = {
28154 (char *) "val", NULL
28155 };
28156
28157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28158 ecode1 = SWIG_AsVal_long(obj0, &val1);
28159 if (!SWIG_IsOK(ecode1)) {
28160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28161 }
28162 arg1 = static_cast< long >(val1);
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 wxPyApp::SetMacAboutMenuItemId(arg1);
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_Py_Void();
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 long arg1 ;
28179 long val1 ;
28180 int ecode1 = 0 ;
28181 PyObject * obj0 = 0 ;
28182 char * kwnames[] = {
28183 (char *) "val", NULL
28184 };
28185
28186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28187 ecode1 = SWIG_AsVal_long(obj0, &val1);
28188 if (!SWIG_IsOK(ecode1)) {
28189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28190 }
28191 arg1 = static_cast< long >(val1);
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 resultobj = SWIG_Py_Void();
28199 return resultobj;
28200 fail:
28201 return NULL;
28202 }
28203
28204
28205 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28206 PyObject *resultobj = 0;
28207 long arg1 ;
28208 long val1 ;
28209 int ecode1 = 0 ;
28210 PyObject * obj0 = 0 ;
28211 char * kwnames[] = {
28212 (char *) "val", NULL
28213 };
28214
28215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28216 ecode1 = SWIG_AsVal_long(obj0, &val1);
28217 if (!SWIG_IsOK(ecode1)) {
28218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28219 }
28220 arg1 = static_cast< long >(val1);
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 wxPyApp::SetMacExitMenuItemId(arg1);
28224 wxPyEndAllowThreads(__tstate);
28225 if (PyErr_Occurred()) SWIG_fail;
28226 }
28227 resultobj = SWIG_Py_Void();
28228 return resultobj;
28229 fail:
28230 return NULL;
28231 }
28232
28233
28234 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28235 PyObject *resultobj = 0;
28236 wxString *arg1 = 0 ;
28237 bool temp1 = false ;
28238 PyObject * obj0 = 0 ;
28239 char * kwnames[] = {
28240 (char *) "val", NULL
28241 };
28242
28243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28244 {
28245 arg1 = wxString_in_helper(obj0);
28246 if (arg1 == NULL) SWIG_fail;
28247 temp1 = true;
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28252 wxPyEndAllowThreads(__tstate);
28253 if (PyErr_Occurred()) SWIG_fail;
28254 }
28255 resultobj = SWIG_Py_Void();
28256 {
28257 if (temp1)
28258 delete arg1;
28259 }
28260 return resultobj;
28261 fail:
28262 {
28263 if (temp1)
28264 delete arg1;
28265 }
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 PyObject *resultobj = 0;
28272 wxPyApp *arg1 = (wxPyApp *) 0 ;
28273 void *argp1 = 0 ;
28274 int res1 = 0 ;
28275 PyObject *swig_obj[1] ;
28276
28277 if (!args) SWIG_fail;
28278 swig_obj[0] = args;
28279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28280 if (!SWIG_IsOK(res1)) {
28281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28282 }
28283 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 (arg1)->_BootstrapApp();
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = SWIG_Py_Void();
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28298 PyObject *resultobj = 0;
28299 int result;
28300
28301 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28302 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 result = (int)wxPyApp_GetComCtl32Version();
28305 wxPyEndAllowThreads(__tstate);
28306 if (PyErr_Occurred()) SWIG_fail;
28307 }
28308 resultobj = SWIG_From_int(static_cast< int >(result));
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28316 PyObject *obj;
28317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28318 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28319 return SWIG_Py_Void();
28320 }
28321
28322 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 return SWIG_Python_InitShadowInstance(args);
28324 }
28325
28326 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28327 PyObject *resultobj = 0;
28328
28329 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 wxExit();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_Py_Void();
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 PyObject *resultobj = 0;
28345 bool result;
28346
28347 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28348 {
28349 PyThreadState* __tstate = wxPyBeginAllowThreads();
28350 result = (bool)wxYield();
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28356 }
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28364 PyObject *resultobj = 0;
28365 bool result;
28366
28367 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28368 {
28369 PyThreadState* __tstate = wxPyBeginAllowThreads();
28370 result = (bool)wxYieldIfNeeded();
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 {
28375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28376 }
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj = 0;
28385 wxWindow *arg1 = (wxWindow *) NULL ;
28386 bool arg2 = (bool) false ;
28387 bool result;
28388 void *argp1 = 0 ;
28389 int res1 = 0 ;
28390 bool val2 ;
28391 int ecode2 = 0 ;
28392 PyObject * obj0 = 0 ;
28393 PyObject * obj1 = 0 ;
28394 char * kwnames[] = {
28395 (char *) "win",(char *) "onlyIfNeeded", NULL
28396 };
28397
28398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28399 if (obj0) {
28400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28403 }
28404 arg1 = reinterpret_cast< wxWindow * >(argp1);
28405 }
28406 if (obj1) {
28407 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28408 if (!SWIG_IsOK(ecode2)) {
28409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28410 }
28411 arg2 = static_cast< bool >(val2);
28412 }
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (bool)wxSafeYield(arg1,arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 {
28420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28421 }
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28429 PyObject *resultobj = 0;
28430
28431 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 wxWakeUpIdle();
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 resultobj = SWIG_Py_Void();
28439 return resultobj;
28440 fail:
28441 return NULL;
28442 }
28443
28444
28445 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28446 PyObject *resultobj = 0;
28447 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28448 wxEvent *arg2 = 0 ;
28449 void *argp1 = 0 ;
28450 int res1 = 0 ;
28451 void *argp2 = 0 ;
28452 int res2 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 PyObject * obj1 = 0 ;
28455 char * kwnames[] = {
28456 (char *) "dest",(char *) "event", NULL
28457 };
28458
28459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28461 if (!SWIG_IsOK(res1)) {
28462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28463 }
28464 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28466 if (!SWIG_IsOK(res2)) {
28467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28468 }
28469 if (!argp2) {
28470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28471 }
28472 arg2 = reinterpret_cast< wxEvent * >(argp2);
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 wxPostEvent(arg1,*arg2);
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 resultobj = SWIG_Py_Void();
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 PyObject *resultobj = 0;
28488
28489 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 wxApp_CleanUp();
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 resultobj = SWIG_Py_Void();
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28504 PyObject *resultobj = 0;
28505 wxPyApp *result = 0 ;
28506
28507 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 result = (wxPyApp *)wxPyGetApp();
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 {
28515 resultobj = wxPyMake_wxObject(result, 0);
28516 }
28517 return resultobj;
28518 fail:
28519 return NULL;
28520 }
28521
28522
28523 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28524 PyObject *resultobj = 0;
28525 char *arg1 = (char *) 0 ;
28526 int res1 ;
28527 char *buf1 = 0 ;
28528 int alloc1 = 0 ;
28529 PyObject * obj0 = 0 ;
28530 char * kwnames[] = {
28531 (char *) "encoding", NULL
28532 };
28533
28534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28535 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28536 if (!SWIG_IsOK(res1)) {
28537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28538 }
28539 arg1 = buf1;
28540 {
28541 PyThreadState* __tstate = wxPyBeginAllowThreads();
28542 wxSetDefaultPyEncoding((char const *)arg1);
28543 wxPyEndAllowThreads(__tstate);
28544 if (PyErr_Occurred()) SWIG_fail;
28545 }
28546 resultobj = SWIG_Py_Void();
28547 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28548 return resultobj;
28549 fail:
28550 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28551 return NULL;
28552 }
28553
28554
28555 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28556 PyObject *resultobj = 0;
28557 char *result = 0 ;
28558
28559 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (char *)wxGetDefaultPyEncoding();
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_FromCharPtr(result);
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxEventLoop *result = 0 ;
28576
28577 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = (wxEventLoop *)new wxEventLoop();
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28592 PyObject *resultobj = 0;
28593 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28594 void *argp1 = 0 ;
28595 int res1 = 0 ;
28596 PyObject *swig_obj[1] ;
28597
28598 if (!args) SWIG_fail;
28599 swig_obj[0] = args;
28600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28601 if (!SWIG_IsOK(res1)) {
28602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28603 }
28604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 delete arg1;
28608
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 resultobj = SWIG_Py_Void();
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *resultobj = 0;
28621 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28622 int result;
28623 void *argp1 = 0 ;
28624 int res1 = 0 ;
28625 PyObject *swig_obj[1] ;
28626
28627 if (!args) SWIG_fail;
28628 swig_obj[0] = args;
28629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28630 if (!SWIG_IsOK(res1)) {
28631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28632 }
28633 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (int)(arg1)->Run();
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 resultobj = SWIG_From_int(static_cast< int >(result));
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28648 PyObject *resultobj = 0;
28649 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28650 int arg2 = (int) 0 ;
28651 void *argp1 = 0 ;
28652 int res1 = 0 ;
28653 int val2 ;
28654 int ecode2 = 0 ;
28655 PyObject * obj0 = 0 ;
28656 PyObject * obj1 = 0 ;
28657 char * kwnames[] = {
28658 (char *) "self",(char *) "rc", NULL
28659 };
28660
28661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28663 if (!SWIG_IsOK(res1)) {
28664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28665 }
28666 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28667 if (obj1) {
28668 ecode2 = SWIG_AsVal_int(obj1, &val2);
28669 if (!SWIG_IsOK(ecode2)) {
28670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28671 }
28672 arg2 = static_cast< int >(val2);
28673 }
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 (arg1)->Exit(arg2);
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 resultobj = SWIG_Py_Void();
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28688 PyObject *resultobj = 0;
28689 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28690 bool result;
28691 void *argp1 = 0 ;
28692 int res1 = 0 ;
28693 PyObject *swig_obj[1] ;
28694
28695 if (!args) SWIG_fail;
28696 swig_obj[0] = args;
28697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28698 if (!SWIG_IsOK(res1)) {
28699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28700 }
28701 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28702 {
28703 PyThreadState* __tstate = wxPyBeginAllowThreads();
28704 result = (bool)((wxEventLoop const *)arg1)->Pending();
28705 wxPyEndAllowThreads(__tstate);
28706 if (PyErr_Occurred()) SWIG_fail;
28707 }
28708 {
28709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28710 }
28711 return resultobj;
28712 fail:
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28718 PyObject *resultobj = 0;
28719 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28720 bool result;
28721 void *argp1 = 0 ;
28722 int res1 = 0 ;
28723 PyObject *swig_obj[1] ;
28724
28725 if (!args) SWIG_fail;
28726 swig_obj[0] = args;
28727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28728 if (!SWIG_IsOK(res1)) {
28729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28730 }
28731 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 result = (bool)(arg1)->Dispatch();
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 {
28739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28740 }
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748 PyObject *resultobj = 0;
28749 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28750 bool result;
28751 void *argp1 = 0 ;
28752 int res1 = 0 ;
28753 PyObject *swig_obj[1] ;
28754
28755 if (!args) SWIG_fail;
28756 swig_obj[0] = args;
28757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28760 }
28761 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 {
28769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28770 }
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28778 PyObject *resultobj = 0;
28779 wxEventLoop *result = 0 ;
28780
28781 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (wxEventLoop *)wxEventLoop::GetActive();
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28796 PyObject *resultobj = 0;
28797 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28798 void *argp1 = 0 ;
28799 int res1 = 0 ;
28800 PyObject * obj0 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "loop", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28809 }
28810 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 wxEventLoop::SetActive(arg1);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_Py_Void();
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *obj;
28826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28827 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28828 return SWIG_Py_Void();
28829 }
28830
28831 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28832 return SWIG_Python_InitShadowInstance(args);
28833 }
28834
28835 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj = 0;
28837 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28838 wxEventLoopActivator *result = 0 ;
28839 void *argp1 = 0 ;
28840 int res1 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 char * kwnames[] = {
28843 (char *) "evtLoop", NULL
28844 };
28845
28846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28848 if (!SWIG_IsOK(res1)) {
28849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28850 }
28851 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28852 {
28853 PyThreadState* __tstate = wxPyBeginAllowThreads();
28854 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28855 wxPyEndAllowThreads(__tstate);
28856 if (PyErr_Occurred()) SWIG_fail;
28857 }
28858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28866 PyObject *resultobj = 0;
28867 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28868 void *argp1 = 0 ;
28869 int res1 = 0 ;
28870 PyObject *swig_obj[1] ;
28871
28872 if (!args) SWIG_fail;
28873 swig_obj[0] = args;
28874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28875 if (!SWIG_IsOK(res1)) {
28876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28877 }
28878 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 delete arg1;
28882
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 resultobj = SWIG_Py_Void();
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28894 PyObject *obj;
28895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28896 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28897 return SWIG_Py_Void();
28898 }
28899
28900 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 return SWIG_Python_InitShadowInstance(args);
28902 }
28903
28904 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28905 PyObject *resultobj = 0;
28906 int arg1 = (int) 0 ;
28907 int arg2 = (int) 0 ;
28908 int arg3 = (int) 0 ;
28909 wxAcceleratorEntry *result = 0 ;
28910 int val1 ;
28911 int ecode1 = 0 ;
28912 int val2 ;
28913 int ecode2 = 0 ;
28914 int val3 ;
28915 int ecode3 = 0 ;
28916 PyObject * obj0 = 0 ;
28917 PyObject * obj1 = 0 ;
28918 PyObject * obj2 = 0 ;
28919 char * kwnames[] = {
28920 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28921 };
28922
28923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28924 if (obj0) {
28925 ecode1 = SWIG_AsVal_int(obj0, &val1);
28926 if (!SWIG_IsOK(ecode1)) {
28927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28928 }
28929 arg1 = static_cast< int >(val1);
28930 }
28931 if (obj1) {
28932 ecode2 = SWIG_AsVal_int(obj1, &val2);
28933 if (!SWIG_IsOK(ecode2)) {
28934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28935 }
28936 arg2 = static_cast< int >(val2);
28937 }
28938 if (obj2) {
28939 ecode3 = SWIG_AsVal_int(obj2, &val3);
28940 if (!SWIG_IsOK(ecode3)) {
28941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28942 }
28943 arg3 = static_cast< int >(val3);
28944 }
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28948 wxPyEndAllowThreads(__tstate);
28949 if (PyErr_Occurred()) SWIG_fail;
28950 }
28951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28959 PyObject *resultobj = 0;
28960 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28961 void *argp1 = 0 ;
28962 int res1 = 0 ;
28963 PyObject *swig_obj[1] ;
28964
28965 if (!args) SWIG_fail;
28966 swig_obj[0] = args;
28967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28968 if (!SWIG_IsOK(res1)) {
28969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28970 }
28971 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 delete arg1;
28975
28976 wxPyEndAllowThreads(__tstate);
28977 if (PyErr_Occurred()) SWIG_fail;
28978 }
28979 resultobj = SWIG_Py_Void();
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj = 0;
28988 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28989 int arg2 ;
28990 int arg3 ;
28991 int arg4 ;
28992 void *argp1 = 0 ;
28993 int res1 = 0 ;
28994 int val2 ;
28995 int ecode2 = 0 ;
28996 int val3 ;
28997 int ecode3 = 0 ;
28998 int val4 ;
28999 int ecode4 = 0 ;
29000 PyObject * obj0 = 0 ;
29001 PyObject * obj1 = 0 ;
29002 PyObject * obj2 = 0 ;
29003 PyObject * obj3 = 0 ;
29004 char * kwnames[] = {
29005 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29006 };
29007
29008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29010 if (!SWIG_IsOK(res1)) {
29011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29012 }
29013 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29014 ecode2 = SWIG_AsVal_int(obj1, &val2);
29015 if (!SWIG_IsOK(ecode2)) {
29016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29017 }
29018 arg2 = static_cast< int >(val2);
29019 ecode3 = SWIG_AsVal_int(obj2, &val3);
29020 if (!SWIG_IsOK(ecode3)) {
29021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29022 }
29023 arg3 = static_cast< int >(val3);
29024 ecode4 = SWIG_AsVal_int(obj3, &val4);
29025 if (!SWIG_IsOK(ecode4)) {
29026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29027 }
29028 arg4 = static_cast< int >(val4);
29029 {
29030 PyThreadState* __tstate = wxPyBeginAllowThreads();
29031 (arg1)->Set(arg2,arg3,arg4);
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 resultobj = SWIG_Py_Void();
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29043 PyObject *resultobj = 0;
29044 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29045 int result;
29046 void *argp1 = 0 ;
29047 int res1 = 0 ;
29048 PyObject *swig_obj[1] ;
29049
29050 if (!args) SWIG_fail;
29051 swig_obj[0] = args;
29052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29053 if (!SWIG_IsOK(res1)) {
29054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29055 }
29056 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = (int)(arg1)->GetFlags();
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_From_int(static_cast< int >(result));
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29073 int result;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject *swig_obj[1] ;
29077
29078 if (!args) SWIG_fail;
29079 swig_obj[0] = args;
29080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29083 }
29084 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (int)(arg1)->GetKeyCode();
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 resultobj = SWIG_From_int(static_cast< int >(result));
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 PyObject *resultobj = 0;
29100 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29101 int result;
29102 void *argp1 = 0 ;
29103 int res1 = 0 ;
29104 PyObject *swig_obj[1] ;
29105
29106 if (!args) SWIG_fail;
29107 swig_obj[0] = args;
29108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29109 if (!SWIG_IsOK(res1)) {
29110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29111 }
29112 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = (int)(arg1)->GetCommand();
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_From_int(static_cast< int >(result));
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *obj;
29128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29129 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29130 return SWIG_Py_Void();
29131 }
29132
29133 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 return SWIG_Python_InitShadowInstance(args);
29135 }
29136
29137 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 int arg1 ;
29140 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29141 wxAcceleratorTable *result = 0 ;
29142 PyObject * obj0 = 0 ;
29143 char * kwnames[] = {
29144 (char *) "n", NULL
29145 };
29146
29147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29148 {
29149 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29150 if (arg2) arg1 = PyList_Size(obj0);
29151 else arg1 = 0;
29152 }
29153 {
29154 PyThreadState* __tstate = wxPyBeginAllowThreads();
29155 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29156 wxPyEndAllowThreads(__tstate);
29157 if (PyErr_Occurred()) SWIG_fail;
29158 }
29159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29160 return resultobj;
29161 fail:
29162 return NULL;
29163 }
29164
29165
29166 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29167 PyObject *resultobj = 0;
29168 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29169 void *argp1 = 0 ;
29170 int res1 = 0 ;
29171 PyObject *swig_obj[1] ;
29172
29173 if (!args) SWIG_fail;
29174 swig_obj[0] = args;
29175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29176 if (!SWIG_IsOK(res1)) {
29177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29178 }
29179 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 delete arg1;
29183
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_Py_Void();
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29195 PyObject *resultobj = 0;
29196 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29197 bool result;
29198 void *argp1 = 0 ;
29199 int res1 = 0 ;
29200 PyObject *swig_obj[1] ;
29201
29202 if (!args) SWIG_fail;
29203 swig_obj[0] = args;
29204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29205 if (!SWIG_IsOK(res1)) {
29206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29207 }
29208 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 {
29216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29217 }
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29225 PyObject *obj;
29226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29227 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29228 return SWIG_Py_Void();
29229 }
29230
29231 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 return SWIG_Python_InitShadowInstance(args);
29233 }
29234
29235 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29236 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29237 return 1;
29238 }
29239
29240
29241 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29242 PyObject *pyobj = 0;
29243
29244 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29245 return pyobj;
29246 }
29247
29248
29249 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29250 PyObject *resultobj = 0;
29251 wxString *arg1 = 0 ;
29252 wxAcceleratorEntry *result = 0 ;
29253 bool temp1 = false ;
29254 PyObject * obj0 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "label", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29260 {
29261 arg1 = wxString_in_helper(obj0);
29262 if (arg1 == NULL) SWIG_fail;
29263 temp1 = true;
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29272 {
29273 if (temp1)
29274 delete arg1;
29275 }
29276 return resultobj;
29277 fail:
29278 {
29279 if (temp1)
29280 delete arg1;
29281 }
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN int PanelNameStr_set(PyObject *) {
29287 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29288 return 1;
29289 }
29290
29291
29292 SWIGINTERN PyObject *PanelNameStr_get(void) {
29293 PyObject *pyobj = 0;
29294
29295 {
29296 #if wxUSE_UNICODE
29297 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29298 #else
29299 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29300 #endif
29301 }
29302 return pyobj;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29307 PyObject *resultobj = 0;
29308 wxVisualAttributes *result = 0 ;
29309
29310 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 result = (wxVisualAttributes *)new_wxVisualAttributes();
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29325 PyObject *resultobj = 0;
29326 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29327 void *argp1 = 0 ;
29328 int res1 = 0 ;
29329 PyObject *swig_obj[1] ;
29330
29331 if (!args) SWIG_fail;
29332 swig_obj[0] = args;
29333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29334 if (!SWIG_IsOK(res1)) {
29335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29336 }
29337 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 delete_wxVisualAttributes(arg1);
29341
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 resultobj = SWIG_Py_Void();
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29353 PyObject *resultobj = 0;
29354 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29355 wxFont *arg2 = (wxFont *) 0 ;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 void *argp2 = 0 ;
29359 int res2 = 0 ;
29360 PyObject *swig_obj[2] ;
29361
29362 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29364 if (!SWIG_IsOK(res1)) {
29365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29366 }
29367 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29368 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29369 if (!SWIG_IsOK(res2)) {
29370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29371 }
29372 arg2 = reinterpret_cast< wxFont * >(argp2);
29373 if (arg1) (arg1)->font = *arg2;
29374
29375 resultobj = SWIG_Py_Void();
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29383 PyObject *resultobj = 0;
29384 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29385 wxFont *result = 0 ;
29386 void *argp1 = 0 ;
29387 int res1 = 0 ;
29388 PyObject *swig_obj[1] ;
29389
29390 if (!args) SWIG_fail;
29391 swig_obj[0] = args;
29392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29393 if (!SWIG_IsOK(res1)) {
29394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29395 }
29396 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29397 result = (wxFont *)& ((arg1)->font);
29398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29406 PyObject *resultobj = 0;
29407 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29408 wxColour *arg2 = (wxColour *) 0 ;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 void *argp2 = 0 ;
29412 int res2 = 0 ;
29413 PyObject *swig_obj[2] ;
29414
29415 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29417 if (!SWIG_IsOK(res1)) {
29418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29419 }
29420 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29421 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29422 if (!SWIG_IsOK(res2)) {
29423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29424 }
29425 arg2 = reinterpret_cast< wxColour * >(argp2);
29426 if (arg1) (arg1)->colFg = *arg2;
29427
29428 resultobj = SWIG_Py_Void();
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29436 PyObject *resultobj = 0;
29437 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29438 wxColour *result = 0 ;
29439 void *argp1 = 0 ;
29440 int res1 = 0 ;
29441 PyObject *swig_obj[1] ;
29442
29443 if (!args) SWIG_fail;
29444 swig_obj[0] = args;
29445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29446 if (!SWIG_IsOK(res1)) {
29447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29448 }
29449 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29450 result = (wxColour *)& ((arg1)->colFg);
29451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29461 wxColour *arg2 = (wxColour *) 0 ;
29462 void *argp1 = 0 ;
29463 int res1 = 0 ;
29464 void *argp2 = 0 ;
29465 int res2 = 0 ;
29466 PyObject *swig_obj[2] ;
29467
29468 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29470 if (!SWIG_IsOK(res1)) {
29471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29472 }
29473 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29474 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29475 if (!SWIG_IsOK(res2)) {
29476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29477 }
29478 arg2 = reinterpret_cast< wxColour * >(argp2);
29479 if (arg1) (arg1)->colBg = *arg2;
29480
29481 resultobj = SWIG_Py_Void();
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29489 PyObject *resultobj = 0;
29490 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29491 wxColour *result = 0 ;
29492 void *argp1 = 0 ;
29493 int res1 = 0 ;
29494 PyObject *swig_obj[1] ;
29495
29496 if (!args) SWIG_fail;
29497 swig_obj[0] = args;
29498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29499 if (!SWIG_IsOK(res1)) {
29500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29501 }
29502 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29503 result = (wxColour *)& ((arg1)->colBg);
29504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29512 PyObject *obj;
29513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29514 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29515 return SWIG_Py_Void();
29516 }
29517
29518 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29519 return SWIG_Python_InitShadowInstance(args);
29520 }
29521
29522 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29523 PyObject *resultobj = 0;
29524 wxWindow *arg1 = (wxWindow *) 0 ;
29525 int arg2 = (int) (int)-1 ;
29526 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29527 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29528 wxSize const &arg4_defvalue = wxDefaultSize ;
29529 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29530 long arg5 = (long) 0 ;
29531 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29532 wxString *arg6 = (wxString *) &arg6_defvalue ;
29533 wxWindow *result = 0 ;
29534 void *argp1 = 0 ;
29535 int res1 = 0 ;
29536 int val2 ;
29537 int ecode2 = 0 ;
29538 wxPoint temp3 ;
29539 wxSize temp4 ;
29540 long val5 ;
29541 int ecode5 = 0 ;
29542 bool temp6 = false ;
29543 PyObject * obj0 = 0 ;
29544 PyObject * obj1 = 0 ;
29545 PyObject * obj2 = 0 ;
29546 PyObject * obj3 = 0 ;
29547 PyObject * obj4 = 0 ;
29548 PyObject * obj5 = 0 ;
29549 char * kwnames[] = {
29550 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29551 };
29552
29553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29555 if (!SWIG_IsOK(res1)) {
29556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29557 }
29558 arg1 = reinterpret_cast< wxWindow * >(argp1);
29559 if (obj1) {
29560 ecode2 = SWIG_AsVal_int(obj1, &val2);
29561 if (!SWIG_IsOK(ecode2)) {
29562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29563 }
29564 arg2 = static_cast< int >(val2);
29565 }
29566 if (obj2) {
29567 {
29568 arg3 = &temp3;
29569 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29570 }
29571 }
29572 if (obj3) {
29573 {
29574 arg4 = &temp4;
29575 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29576 }
29577 }
29578 if (obj4) {
29579 ecode5 = SWIG_AsVal_long(obj4, &val5);
29580 if (!SWIG_IsOK(ecode5)) {
29581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29582 }
29583 arg5 = static_cast< long >(val5);
29584 }
29585 if (obj5) {
29586 {
29587 arg6 = wxString_in_helper(obj5);
29588 if (arg6 == NULL) SWIG_fail;
29589 temp6 = true;
29590 }
29591 }
29592 {
29593 if (!wxPyCheckForApp()) SWIG_fail;
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29600 {
29601 if (temp6)
29602 delete arg6;
29603 }
29604 return resultobj;
29605 fail:
29606 {
29607 if (temp6)
29608 delete arg6;
29609 }
29610 return NULL;
29611 }
29612
29613
29614 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29615 PyObject *resultobj = 0;
29616 wxWindow *result = 0 ;
29617
29618 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29619 {
29620 if (!wxPyCheckForApp()) SWIG_fail;
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (wxWindow *)new wxWindow();
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29634 PyObject *resultobj = 0;
29635 wxWindow *arg1 = (wxWindow *) 0 ;
29636 wxWindow *arg2 = (wxWindow *) 0 ;
29637 int arg3 = (int) (int)-1 ;
29638 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29639 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29640 wxSize const &arg5_defvalue = wxDefaultSize ;
29641 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29642 long arg6 = (long) 0 ;
29643 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29644 wxString *arg7 = (wxString *) &arg7_defvalue ;
29645 bool result;
29646 void *argp1 = 0 ;
29647 int res1 = 0 ;
29648 void *argp2 = 0 ;
29649 int res2 = 0 ;
29650 int val3 ;
29651 int ecode3 = 0 ;
29652 wxPoint temp4 ;
29653 wxSize temp5 ;
29654 long val6 ;
29655 int ecode6 = 0 ;
29656 bool temp7 = false ;
29657 PyObject * obj0 = 0 ;
29658 PyObject * obj1 = 0 ;
29659 PyObject * obj2 = 0 ;
29660 PyObject * obj3 = 0 ;
29661 PyObject * obj4 = 0 ;
29662 PyObject * obj5 = 0 ;
29663 PyObject * obj6 = 0 ;
29664 char * kwnames[] = {
29665 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29666 };
29667
29668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29670 if (!SWIG_IsOK(res1)) {
29671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29672 }
29673 arg1 = reinterpret_cast< wxWindow * >(argp1);
29674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29675 if (!SWIG_IsOK(res2)) {
29676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29677 }
29678 arg2 = reinterpret_cast< wxWindow * >(argp2);
29679 if (obj2) {
29680 ecode3 = SWIG_AsVal_int(obj2, &val3);
29681 if (!SWIG_IsOK(ecode3)) {
29682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29683 }
29684 arg3 = static_cast< int >(val3);
29685 }
29686 if (obj3) {
29687 {
29688 arg4 = &temp4;
29689 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29690 }
29691 }
29692 if (obj4) {
29693 {
29694 arg5 = &temp5;
29695 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29696 }
29697 }
29698 if (obj5) {
29699 ecode6 = SWIG_AsVal_long(obj5, &val6);
29700 if (!SWIG_IsOK(ecode6)) {
29701 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29702 }
29703 arg6 = static_cast< long >(val6);
29704 }
29705 if (obj6) {
29706 {
29707 arg7 = wxString_in_helper(obj6);
29708 if (arg7 == NULL) SWIG_fail;
29709 temp7 = true;
29710 }
29711 }
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 {
29719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29720 }
29721 {
29722 if (temp7)
29723 delete arg7;
29724 }
29725 return resultobj;
29726 fail:
29727 {
29728 if (temp7)
29729 delete arg7;
29730 }
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29736 PyObject *resultobj = 0;
29737 wxWindow *arg1 = (wxWindow *) 0 ;
29738 bool arg2 = (bool) false ;
29739 bool result;
29740 void *argp1 = 0 ;
29741 int res1 = 0 ;
29742 bool val2 ;
29743 int ecode2 = 0 ;
29744 PyObject * obj0 = 0 ;
29745 PyObject * obj1 = 0 ;
29746 char * kwnames[] = {
29747 (char *) "self",(char *) "force", NULL
29748 };
29749
29750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29752 if (!SWIG_IsOK(res1)) {
29753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29754 }
29755 arg1 = reinterpret_cast< wxWindow * >(argp1);
29756 if (obj1) {
29757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29758 if (!SWIG_IsOK(ecode2)) {
29759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29760 }
29761 arg2 = static_cast< bool >(val2);
29762 }
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = (bool)(arg1)->Close(arg2);
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 {
29770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29771 }
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29779 PyObject *resultobj = 0;
29780 wxWindow *arg1 = (wxWindow *) 0 ;
29781 bool result;
29782 void *argp1 = 0 ;
29783 int res1 = 0 ;
29784 PyObject *swig_obj[1] ;
29785
29786 if (!args) SWIG_fail;
29787 swig_obj[0] = args;
29788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29789 if (!SWIG_IsOK(res1)) {
29790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29791 }
29792 arg1 = reinterpret_cast< wxWindow * >(argp1);
29793 {
29794 PyThreadState* __tstate = wxPyBeginAllowThreads();
29795 result = (bool)(arg1)->Destroy();
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 {
29800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29801 }
29802 return resultobj;
29803 fail:
29804 return NULL;
29805 }
29806
29807
29808 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29809 PyObject *resultobj = 0;
29810 wxWindow *arg1 = (wxWindow *) 0 ;
29811 bool result;
29812 void *argp1 = 0 ;
29813 int res1 = 0 ;
29814 PyObject *swig_obj[1] ;
29815
29816 if (!args) SWIG_fail;
29817 swig_obj[0] = args;
29818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29821 }
29822 arg1 = reinterpret_cast< wxWindow * >(argp1);
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 result = (bool)(arg1)->DestroyChildren();
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 {
29830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29831 }
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29839 PyObject *resultobj = 0;
29840 wxWindow *arg1 = (wxWindow *) 0 ;
29841 bool result;
29842 void *argp1 = 0 ;
29843 int res1 = 0 ;
29844 PyObject *swig_obj[1] ;
29845
29846 if (!args) SWIG_fail;
29847 swig_obj[0] = args;
29848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29851 }
29852 arg1 = reinterpret_cast< wxWindow * >(argp1);
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 {
29860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29861 }
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj = 0;
29870 wxWindow *arg1 = (wxWindow *) 0 ;
29871 wxString *arg2 = 0 ;
29872 void *argp1 = 0 ;
29873 int res1 = 0 ;
29874 bool temp2 = false ;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 char * kwnames[] = {
29878 (char *) "self",(char *) "label", NULL
29879 };
29880
29881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29885 }
29886 arg1 = reinterpret_cast< wxWindow * >(argp1);
29887 {
29888 arg2 = wxString_in_helper(obj1);
29889 if (arg2 == NULL) SWIG_fail;
29890 temp2 = true;
29891 }
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 (arg1)->SetLabel((wxString const &)*arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_Py_Void();
29899 {
29900 if (temp2)
29901 delete arg2;
29902 }
29903 return resultobj;
29904 fail:
29905 {
29906 if (temp2)
29907 delete arg2;
29908 }
29909 return NULL;
29910 }
29911
29912
29913 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29914 PyObject *resultobj = 0;
29915 wxWindow *arg1 = (wxWindow *) 0 ;
29916 wxString result;
29917 void *argp1 = 0 ;
29918 int res1 = 0 ;
29919 PyObject *swig_obj[1] ;
29920
29921 if (!args) SWIG_fail;
29922 swig_obj[0] = args;
29923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29924 if (!SWIG_IsOK(res1)) {
29925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29926 }
29927 arg1 = reinterpret_cast< wxWindow * >(argp1);
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 result = ((wxWindow const *)arg1)->GetLabel();
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 {
29935 #if wxUSE_UNICODE
29936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29937 #else
29938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29939 #endif
29940 }
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj = 0;
29949 wxWindow *arg1 = (wxWindow *) 0 ;
29950 wxString *arg2 = 0 ;
29951 void *argp1 = 0 ;
29952 int res1 = 0 ;
29953 bool temp2 = false ;
29954 PyObject * obj0 = 0 ;
29955 PyObject * obj1 = 0 ;
29956 char * kwnames[] = {
29957 (char *) "self",(char *) "name", NULL
29958 };
29959
29960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29962 if (!SWIG_IsOK(res1)) {
29963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29964 }
29965 arg1 = reinterpret_cast< wxWindow * >(argp1);
29966 {
29967 arg2 = wxString_in_helper(obj1);
29968 if (arg2 == NULL) SWIG_fail;
29969 temp2 = true;
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 (arg1)->SetName((wxString const &)*arg2);
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 resultobj = SWIG_Py_Void();
29978 {
29979 if (temp2)
29980 delete arg2;
29981 }
29982 return resultobj;
29983 fail:
29984 {
29985 if (temp2)
29986 delete arg2;
29987 }
29988 return NULL;
29989 }
29990
29991
29992 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29993 PyObject *resultobj = 0;
29994 wxWindow *arg1 = (wxWindow *) 0 ;
29995 wxString result;
29996 void *argp1 = 0 ;
29997 int res1 = 0 ;
29998 PyObject *swig_obj[1] ;
29999
30000 if (!args) SWIG_fail;
30001 swig_obj[0] = args;
30002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30005 }
30006 arg1 = reinterpret_cast< wxWindow * >(argp1);
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = ((wxWindow const *)arg1)->GetName();
30010 wxPyEndAllowThreads(__tstate);
30011 if (PyErr_Occurred()) SWIG_fail;
30012 }
30013 {
30014 #if wxUSE_UNICODE
30015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30016 #else
30017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30018 #endif
30019 }
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30027 PyObject *resultobj = 0;
30028 wxWindow *arg1 = (wxWindow *) 0 ;
30029 wxWindowVariant arg2 ;
30030 void *argp1 = 0 ;
30031 int res1 = 0 ;
30032 int val2 ;
30033 int ecode2 = 0 ;
30034 PyObject * obj0 = 0 ;
30035 PyObject * obj1 = 0 ;
30036 char * kwnames[] = {
30037 (char *) "self",(char *) "variant", NULL
30038 };
30039
30040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30044 }
30045 arg1 = reinterpret_cast< wxWindow * >(argp1);
30046 ecode2 = SWIG_AsVal_int(obj1, &val2);
30047 if (!SWIG_IsOK(ecode2)) {
30048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30049 }
30050 arg2 = static_cast< wxWindowVariant >(val2);
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 (arg1)->SetWindowVariant(arg2);
30054 wxPyEndAllowThreads(__tstate);
30055 if (PyErr_Occurred()) SWIG_fail;
30056 }
30057 resultobj = SWIG_Py_Void();
30058 return resultobj;
30059 fail:
30060 return NULL;
30061 }
30062
30063
30064 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30065 PyObject *resultobj = 0;
30066 wxWindow *arg1 = (wxWindow *) 0 ;
30067 wxWindowVariant result;
30068 void *argp1 = 0 ;
30069 int res1 = 0 ;
30070 PyObject *swig_obj[1] ;
30071
30072 if (!args) SWIG_fail;
30073 swig_obj[0] = args;
30074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30075 if (!SWIG_IsOK(res1)) {
30076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30077 }
30078 arg1 = reinterpret_cast< wxWindow * >(argp1);
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 resultobj = SWIG_From_int(static_cast< int >(result));
30086 return resultobj;
30087 fail:
30088 return NULL;
30089 }
30090
30091
30092 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30093 PyObject *resultobj = 0;
30094 wxWindow *arg1 = (wxWindow *) 0 ;
30095 int arg2 ;
30096 void *argp1 = 0 ;
30097 int res1 = 0 ;
30098 int val2 ;
30099 int ecode2 = 0 ;
30100 PyObject * obj0 = 0 ;
30101 PyObject * obj1 = 0 ;
30102 char * kwnames[] = {
30103 (char *) "self",(char *) "winid", NULL
30104 };
30105
30106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30108 if (!SWIG_IsOK(res1)) {
30109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30110 }
30111 arg1 = reinterpret_cast< wxWindow * >(argp1);
30112 ecode2 = SWIG_AsVal_int(obj1, &val2);
30113 if (!SWIG_IsOK(ecode2)) {
30114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30115 }
30116 arg2 = static_cast< int >(val2);
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 (arg1)->SetId(arg2);
30120 wxPyEndAllowThreads(__tstate);
30121 if (PyErr_Occurred()) SWIG_fail;
30122 }
30123 resultobj = SWIG_Py_Void();
30124 return resultobj;
30125 fail:
30126 return NULL;
30127 }
30128
30129
30130 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30131 PyObject *resultobj = 0;
30132 wxWindow *arg1 = (wxWindow *) 0 ;
30133 int result;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 PyObject *swig_obj[1] ;
30137
30138 if (!args) SWIG_fail;
30139 swig_obj[0] = args;
30140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30141 if (!SWIG_IsOK(res1)) {
30142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30143 }
30144 arg1 = reinterpret_cast< wxWindow * >(argp1);
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 result = (int)((wxWindow const *)arg1)->GetId();
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 resultobj = SWIG_From_int(static_cast< int >(result));
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 int result;
30161
30162 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 result = (int)wxWindow::NewControlId();
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_From_int(static_cast< int >(result));
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 int arg1 ;
30179 int result;
30180 int val1 ;
30181 int ecode1 = 0 ;
30182 PyObject * obj0 = 0 ;
30183 char * kwnames[] = {
30184 (char *) "winid", NULL
30185 };
30186
30187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30188 ecode1 = SWIG_AsVal_int(obj0, &val1);
30189 if (!SWIG_IsOK(ecode1)) {
30190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30191 }
30192 arg1 = static_cast< int >(val1);
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (int)wxWindow::NextControlId(arg1);
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 resultobj = SWIG_From_int(static_cast< int >(result));
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30207 PyObject *resultobj = 0;
30208 int arg1 ;
30209 int result;
30210 int val1 ;
30211 int ecode1 = 0 ;
30212 PyObject * obj0 = 0 ;
30213 char * kwnames[] = {
30214 (char *) "winid", NULL
30215 };
30216
30217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30218 ecode1 = SWIG_AsVal_int(obj0, &val1);
30219 if (!SWIG_IsOK(ecode1)) {
30220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30221 }
30222 arg1 = static_cast< int >(val1);
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 result = (int)wxWindow::PrevControlId(arg1);
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 resultobj = SWIG_From_int(static_cast< int >(result));
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj = 0;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 wxSize *arg2 = 0 ;
30240 void *argp1 = 0 ;
30241 int res1 = 0 ;
30242 wxSize temp2 ;
30243 PyObject * obj0 = 0 ;
30244 PyObject * obj1 = 0 ;
30245 char * kwnames[] = {
30246 (char *) "self",(char *) "size", NULL
30247 };
30248
30249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30251 if (!SWIG_IsOK(res1)) {
30252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30253 }
30254 arg1 = reinterpret_cast< wxWindow * >(argp1);
30255 {
30256 arg2 = &temp2;
30257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30258 }
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 (arg1)->SetSize((wxSize const &)*arg2);
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_Py_Void();
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj = 0;
30274 wxWindow *arg1 = (wxWindow *) 0 ;
30275 int arg2 ;
30276 int arg3 ;
30277 int arg4 ;
30278 int arg5 ;
30279 int arg6 = (int) wxSIZE_AUTO ;
30280 void *argp1 = 0 ;
30281 int res1 = 0 ;
30282 int val2 ;
30283 int ecode2 = 0 ;
30284 int val3 ;
30285 int ecode3 = 0 ;
30286 int val4 ;
30287 int ecode4 = 0 ;
30288 int val5 ;
30289 int ecode5 = 0 ;
30290 int val6 ;
30291 int ecode6 = 0 ;
30292 PyObject * obj0 = 0 ;
30293 PyObject * obj1 = 0 ;
30294 PyObject * obj2 = 0 ;
30295 PyObject * obj3 = 0 ;
30296 PyObject * obj4 = 0 ;
30297 PyObject * obj5 = 0 ;
30298 char * kwnames[] = {
30299 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30300 };
30301
30302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 ecode2 = SWIG_AsVal_int(obj1, &val2);
30309 if (!SWIG_IsOK(ecode2)) {
30310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30311 }
30312 arg2 = static_cast< int >(val2);
30313 ecode3 = SWIG_AsVal_int(obj2, &val3);
30314 if (!SWIG_IsOK(ecode3)) {
30315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30316 }
30317 arg3 = static_cast< int >(val3);
30318 ecode4 = SWIG_AsVal_int(obj3, &val4);
30319 if (!SWIG_IsOK(ecode4)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30321 }
30322 arg4 = static_cast< int >(val4);
30323 ecode5 = SWIG_AsVal_int(obj4, &val5);
30324 if (!SWIG_IsOK(ecode5)) {
30325 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30326 }
30327 arg5 = static_cast< int >(val5);
30328 if (obj5) {
30329 ecode6 = SWIG_AsVal_int(obj5, &val6);
30330 if (!SWIG_IsOK(ecode6)) {
30331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30332 }
30333 arg6 = static_cast< int >(val6);
30334 }
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 resultobj = SWIG_Py_Void();
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = 0;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 wxRect *arg2 = 0 ;
30352 int arg3 = (int) wxSIZE_AUTO ;
30353 void *argp1 = 0 ;
30354 int res1 = 0 ;
30355 wxRect temp2 ;
30356 int val3 ;
30357 int ecode3 = 0 ;
30358 PyObject * obj0 = 0 ;
30359 PyObject * obj1 = 0 ;
30360 PyObject * obj2 = 0 ;
30361 char * kwnames[] = {
30362 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30363 };
30364
30365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30367 if (!SWIG_IsOK(res1)) {
30368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30369 }
30370 arg1 = reinterpret_cast< wxWindow * >(argp1);
30371 {
30372 arg2 = &temp2;
30373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30374 }
30375 if (obj2) {
30376 ecode3 = SWIG_AsVal_int(obj2, &val3);
30377 if (!SWIG_IsOK(ecode3)) {
30378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30379 }
30380 arg3 = static_cast< int >(val3);
30381 }
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_Py_Void();
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj = 0;
30397 wxWindow *arg1 = (wxWindow *) 0 ;
30398 int arg2 ;
30399 int arg3 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 int val2 ;
30403 int ecode2 = 0 ;
30404 int val3 ;
30405 int ecode3 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char * kwnames[] = {
30410 (char *) "self",(char *) "width",(char *) "height", NULL
30411 };
30412
30413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30417 }
30418 arg1 = reinterpret_cast< wxWindow * >(argp1);
30419 ecode2 = SWIG_AsVal_int(obj1, &val2);
30420 if (!SWIG_IsOK(ecode2)) {
30421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30422 }
30423 arg2 = static_cast< int >(val2);
30424 ecode3 = SWIG_AsVal_int(obj2, &val3);
30425 if (!SWIG_IsOK(ecode3)) {
30426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30427 }
30428 arg3 = static_cast< int >(val3);
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 (arg1)->SetSize(arg2,arg3);
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 resultobj = SWIG_Py_Void();
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30443 PyObject *resultobj = 0;
30444 wxWindow *arg1 = (wxWindow *) 0 ;
30445 wxPoint *arg2 = 0 ;
30446 int arg3 = (int) wxSIZE_USE_EXISTING ;
30447 void *argp1 = 0 ;
30448 int res1 = 0 ;
30449 wxPoint temp2 ;
30450 int val3 ;
30451 int ecode3 = 0 ;
30452 PyObject * obj0 = 0 ;
30453 PyObject * obj1 = 0 ;
30454 PyObject * obj2 = 0 ;
30455 char * kwnames[] = {
30456 (char *) "self",(char *) "pt",(char *) "flags", NULL
30457 };
30458
30459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30463 }
30464 arg1 = reinterpret_cast< wxWindow * >(argp1);
30465 {
30466 arg2 = &temp2;
30467 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30468 }
30469 if (obj2) {
30470 ecode3 = SWIG_AsVal_int(obj2, &val3);
30471 if (!SWIG_IsOK(ecode3)) {
30472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30473 }
30474 arg3 = static_cast< int >(val3);
30475 }
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 (arg1)->Move((wxPoint const &)*arg2,arg3);
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_Py_Void();
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj = 0;
30491 wxWindow *arg1 = (wxWindow *) 0 ;
30492 int arg2 ;
30493 int arg3 ;
30494 int arg4 = (int) wxSIZE_USE_EXISTING ;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 int val2 ;
30498 int ecode2 = 0 ;
30499 int val3 ;
30500 int ecode3 = 0 ;
30501 int val4 ;
30502 int ecode4 = 0 ;
30503 PyObject * obj0 = 0 ;
30504 PyObject * obj1 = 0 ;
30505 PyObject * obj2 = 0 ;
30506 PyObject * obj3 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30515 }
30516 arg1 = reinterpret_cast< wxWindow * >(argp1);
30517 ecode2 = SWIG_AsVal_int(obj1, &val2);
30518 if (!SWIG_IsOK(ecode2)) {
30519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30520 }
30521 arg2 = static_cast< int >(val2);
30522 ecode3 = SWIG_AsVal_int(obj2, &val3);
30523 if (!SWIG_IsOK(ecode3)) {
30524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30525 }
30526 arg3 = static_cast< int >(val3);
30527 if (obj3) {
30528 ecode4 = SWIG_AsVal_int(obj3, &val4);
30529 if (!SWIG_IsOK(ecode4)) {
30530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30531 }
30532 arg4 = static_cast< int >(val4);
30533 }
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 (arg1)->Move(arg2,arg3,arg4);
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 resultobj = SWIG_Py_Void();
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30548 PyObject *resultobj = 0;
30549 wxWindow *arg1 = (wxWindow *) 0 ;
30550 wxSize const &arg2_defvalue = wxDefaultSize ;
30551 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30552 void *argp1 = 0 ;
30553 int res1 = 0 ;
30554 wxSize temp2 ;
30555 PyObject * obj0 = 0 ;
30556 PyObject * obj1 = 0 ;
30557 char * kwnames[] = {
30558 (char *) "self",(char *) "size", NULL
30559 };
30560
30561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30563 if (!SWIG_IsOK(res1)) {
30564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30565 }
30566 arg1 = reinterpret_cast< wxWindow * >(argp1);
30567 if (obj1) {
30568 {
30569 arg2 = &temp2;
30570 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30571 }
30572 }
30573 {
30574 PyThreadState* __tstate = wxPyBeginAllowThreads();
30575 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30576 wxPyEndAllowThreads(__tstate);
30577 if (PyErr_Occurred()) SWIG_fail;
30578 }
30579 resultobj = SWIG_Py_Void();
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 PyObject *resultobj = 0;
30588 wxWindow *arg1 = (wxWindow *) 0 ;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 PyObject *swig_obj[1] ;
30592
30593 if (!args) SWIG_fail;
30594 swig_obj[0] = args;
30595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 (arg1)->Raise();
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_Py_Void();
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 PyObject *resultobj = 0;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 void *argp1 = 0 ;
30617 int res1 = 0 ;
30618 PyObject *swig_obj[1] ;
30619
30620 if (!args) SWIG_fail;
30621 swig_obj[0] = args;
30622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30625 }
30626 arg1 = reinterpret_cast< wxWindow * >(argp1);
30627 {
30628 PyThreadState* __tstate = wxPyBeginAllowThreads();
30629 (arg1)->Lower();
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 resultobj = SWIG_Py_Void();
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj = 0;
30642 wxWindow *arg1 = (wxWindow *) 0 ;
30643 wxSize *arg2 = 0 ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 wxSize temp2 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "size", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 {
30660 arg2 = &temp2;
30661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 (arg1)->SetClientSize((wxSize const &)*arg2);
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_Py_Void();
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 wxWindow *arg1 = (wxWindow *) 0 ;
30679 int arg2 ;
30680 int arg3 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 int val2 ;
30684 int ecode2 = 0 ;
30685 int val3 ;
30686 int ecode3 = 0 ;
30687 PyObject * obj0 = 0 ;
30688 PyObject * obj1 = 0 ;
30689 PyObject * obj2 = 0 ;
30690 char * kwnames[] = {
30691 (char *) "self",(char *) "width",(char *) "height", NULL
30692 };
30693
30694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30696 if (!SWIG_IsOK(res1)) {
30697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30698 }
30699 arg1 = reinterpret_cast< wxWindow * >(argp1);
30700 ecode2 = SWIG_AsVal_int(obj1, &val2);
30701 if (!SWIG_IsOK(ecode2)) {
30702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30703 }
30704 arg2 = static_cast< int >(val2);
30705 ecode3 = SWIG_AsVal_int(obj2, &val3);
30706 if (!SWIG_IsOK(ecode3)) {
30707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30708 }
30709 arg3 = static_cast< int >(val3);
30710 {
30711 PyThreadState* __tstate = wxPyBeginAllowThreads();
30712 (arg1)->SetClientSize(arg2,arg3);
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 resultobj = SWIG_Py_Void();
30717 return resultobj;
30718 fail:
30719 return NULL;
30720 }
30721
30722
30723 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30724 PyObject *resultobj = 0;
30725 wxWindow *arg1 = (wxWindow *) 0 ;
30726 wxRect *arg2 = 0 ;
30727 void *argp1 = 0 ;
30728 int res1 = 0 ;
30729 wxRect temp2 ;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732 char * kwnames[] = {
30733 (char *) "self",(char *) "rect", NULL
30734 };
30735
30736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30740 }
30741 arg1 = reinterpret_cast< wxWindow * >(argp1);
30742 {
30743 arg2 = &temp2;
30744 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30745 }
30746 {
30747 PyThreadState* __tstate = wxPyBeginAllowThreads();
30748 (arg1)->SetClientSize((wxRect const &)*arg2);
30749 wxPyEndAllowThreads(__tstate);
30750 if (PyErr_Occurred()) SWIG_fail;
30751 }
30752 resultobj = SWIG_Py_Void();
30753 return resultobj;
30754 fail:
30755 return NULL;
30756 }
30757
30758
30759 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30760 PyObject *resultobj = 0;
30761 wxWindow *arg1 = (wxWindow *) 0 ;
30762 wxPoint result;
30763 void *argp1 = 0 ;
30764 int res1 = 0 ;
30765 PyObject *swig_obj[1] ;
30766
30767 if (!args) SWIG_fail;
30768 swig_obj[0] = args;
30769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30770 if (!SWIG_IsOK(res1)) {
30771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30772 }
30773 arg1 = reinterpret_cast< wxWindow * >(argp1);
30774 {
30775 PyThreadState* __tstate = wxPyBeginAllowThreads();
30776 result = ((wxWindow const *)arg1)->GetPosition();
30777 wxPyEndAllowThreads(__tstate);
30778 if (PyErr_Occurred()) SWIG_fail;
30779 }
30780 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30788 PyObject *resultobj = 0;
30789 wxWindow *arg1 = (wxWindow *) 0 ;
30790 int *arg2 = (int *) 0 ;
30791 int *arg3 = (int *) 0 ;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 int temp2 ;
30795 int res2 = SWIG_TMPOBJ ;
30796 int temp3 ;
30797 int res3 = SWIG_TMPOBJ ;
30798 PyObject *swig_obj[1] ;
30799
30800 arg2 = &temp2;
30801 arg3 = &temp3;
30802 if (!args) SWIG_fail;
30803 swig_obj[0] = args;
30804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30805 if (!SWIG_IsOK(res1)) {
30806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30807 }
30808 arg1 = reinterpret_cast< wxWindow * >(argp1);
30809 {
30810 PyThreadState* __tstate = wxPyBeginAllowThreads();
30811 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30812 wxPyEndAllowThreads(__tstate);
30813 if (PyErr_Occurred()) SWIG_fail;
30814 }
30815 resultobj = SWIG_Py_Void();
30816 if (SWIG_IsTmpObj(res2)) {
30817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30818 } else {
30819 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30821 }
30822 if (SWIG_IsTmpObj(res3)) {
30823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30824 } else {
30825 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 wxPoint result;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 PyObject *swig_obj[1] ;
30841
30842 if (!args) SWIG_fail;
30843 swig_obj[0] = args;
30844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30847 }
30848 arg1 = reinterpret_cast< wxWindow * >(argp1);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = ((wxWindow const *)arg1)->GetScreenPosition();
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30856 return resultobj;
30857 fail:
30858 return NULL;
30859 }
30860
30861
30862 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30863 PyObject *resultobj = 0;
30864 wxWindow *arg1 = (wxWindow *) 0 ;
30865 int *arg2 = (int *) 0 ;
30866 int *arg3 = (int *) 0 ;
30867 void *argp1 = 0 ;
30868 int res1 = 0 ;
30869 int temp2 ;
30870 int res2 = SWIG_TMPOBJ ;
30871 int temp3 ;
30872 int res3 = SWIG_TMPOBJ ;
30873 PyObject *swig_obj[1] ;
30874
30875 arg2 = &temp2;
30876 arg3 = &temp3;
30877 if (!args) SWIG_fail;
30878 swig_obj[0] = args;
30879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30880 if (!SWIG_IsOK(res1)) {
30881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30882 }
30883 arg1 = reinterpret_cast< wxWindow * >(argp1);
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 resultobj = SWIG_Py_Void();
30891 if (SWIG_IsTmpObj(res2)) {
30892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30893 } else {
30894 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30896 }
30897 if (SWIG_IsTmpObj(res3)) {
30898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30899 } else {
30900 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 wxRect result;
30913 void *argp1 = 0 ;
30914 int res1 = 0 ;
30915 PyObject *swig_obj[1] ;
30916
30917 if (!args) SWIG_fail;
30918 swig_obj[0] = args;
30919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30922 }
30923 arg1 = reinterpret_cast< wxWindow * >(argp1);
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = ((wxWindow const *)arg1)->GetScreenRect();
30927 wxPyEndAllowThreads(__tstate);
30928 if (PyErr_Occurred()) SWIG_fail;
30929 }
30930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30938 PyObject *resultobj = 0;
30939 wxWindow *arg1 = (wxWindow *) 0 ;
30940 wxSize result;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 PyObject *swig_obj[1] ;
30944
30945 if (!args) SWIG_fail;
30946 swig_obj[0] = args;
30947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30948 if (!SWIG_IsOK(res1)) {
30949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30950 }
30951 arg1 = reinterpret_cast< wxWindow * >(argp1);
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = ((wxWindow const *)arg1)->GetSize();
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30966 PyObject *resultobj = 0;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 int *arg2 = (int *) 0 ;
30969 int *arg3 = (int *) 0 ;
30970 void *argp1 = 0 ;
30971 int res1 = 0 ;
30972 int temp2 ;
30973 int res2 = SWIG_TMPOBJ ;
30974 int temp3 ;
30975 int res3 = SWIG_TMPOBJ ;
30976 PyObject *swig_obj[1] ;
30977
30978 arg2 = &temp2;
30979 arg3 = &temp3;
30980 if (!args) SWIG_fail;
30981 swig_obj[0] = args;
30982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30983 if (!SWIG_IsOK(res1)) {
30984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30985 }
30986 arg1 = reinterpret_cast< wxWindow * >(argp1);
30987 {
30988 PyThreadState* __tstate = wxPyBeginAllowThreads();
30989 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30990 wxPyEndAllowThreads(__tstate);
30991 if (PyErr_Occurred()) SWIG_fail;
30992 }
30993 resultobj = SWIG_Py_Void();
30994 if (SWIG_IsTmpObj(res2)) {
30995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30996 } else {
30997 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30999 }
31000 if (SWIG_IsTmpObj(res3)) {
31001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31002 } else {
31003 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31005 }
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 wxRect result;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 PyObject *swig_obj[1] ;
31019
31020 if (!args) SWIG_fail;
31021 swig_obj[0] = args;
31022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31025 }
31026 arg1 = reinterpret_cast< wxWindow * >(argp1);
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = ((wxWindow const *)arg1)->GetRect();
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 wxWindow *arg1 = (wxWindow *) 0 ;
31043 wxSize result;
31044 void *argp1 = 0 ;
31045 int res1 = 0 ;
31046 PyObject *swig_obj[1] ;
31047
31048 if (!args) SWIG_fail;
31049 swig_obj[0] = args;
31050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31051 if (!SWIG_IsOK(res1)) {
31052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31053 }
31054 arg1 = reinterpret_cast< wxWindow * >(argp1);
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = ((wxWindow const *)arg1)->GetClientSize();
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31069 PyObject *resultobj = 0;
31070 wxWindow *arg1 = (wxWindow *) 0 ;
31071 int *arg2 = (int *) 0 ;
31072 int *arg3 = (int *) 0 ;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 int temp2 ;
31076 int res2 = SWIG_TMPOBJ ;
31077 int temp3 ;
31078 int res3 = SWIG_TMPOBJ ;
31079 PyObject *swig_obj[1] ;
31080
31081 arg2 = &temp2;
31082 arg3 = &temp3;
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31088 }
31089 arg1 = reinterpret_cast< wxWindow * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_Py_Void();
31097 if (SWIG_IsTmpObj(res2)) {
31098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31099 } else {
31100 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31102 }
31103 if (SWIG_IsTmpObj(res3)) {
31104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31105 } else {
31106 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31108 }
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31116 PyObject *resultobj = 0;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 wxPoint result;
31119 void *argp1 = 0 ;
31120 int res1 = 0 ;
31121 PyObject *swig_obj[1] ;
31122
31123 if (!args) SWIG_fail;
31124 swig_obj[0] = args;
31125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31126 if (!SWIG_IsOK(res1)) {
31127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31128 }
31129 arg1 = reinterpret_cast< wxWindow * >(argp1);
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31144 PyObject *resultobj = 0;
31145 wxWindow *arg1 = (wxWindow *) 0 ;
31146 wxRect result;
31147 void *argp1 = 0 ;
31148 int res1 = 0 ;
31149 PyObject *swig_obj[1] ;
31150
31151 if (!args) SWIG_fail;
31152 swig_obj[0] = args;
31153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31154 if (!SWIG_IsOK(res1)) {
31155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31156 }
31157 arg1 = reinterpret_cast< wxWindow * >(argp1);
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 result = ((wxWindow const *)arg1)->GetClientRect();
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31172 PyObject *resultobj = 0;
31173 wxWindow *arg1 = (wxWindow *) 0 ;
31174 wxSize result;
31175 void *argp1 = 0 ;
31176 int res1 = 0 ;
31177 PyObject *swig_obj[1] ;
31178
31179 if (!args) SWIG_fail;
31180 swig_obj[0] = args;
31181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31182 if (!SWIG_IsOK(res1)) {
31183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31184 }
31185 arg1 = reinterpret_cast< wxWindow * >(argp1);
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 result = ((wxWindow const *)arg1)->GetBestSize();
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31200 PyObject *resultobj = 0;
31201 wxWindow *arg1 = (wxWindow *) 0 ;
31202 int *arg2 = (int *) 0 ;
31203 int *arg3 = (int *) 0 ;
31204 void *argp1 = 0 ;
31205 int res1 = 0 ;
31206 int temp2 ;
31207 int res2 = SWIG_TMPOBJ ;
31208 int temp3 ;
31209 int res3 = SWIG_TMPOBJ ;
31210 PyObject *swig_obj[1] ;
31211
31212 arg2 = &temp2;
31213 arg3 = &temp3;
31214 if (!args) SWIG_fail;
31215 swig_obj[0] = args;
31216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31217 if (!SWIG_IsOK(res1)) {
31218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31219 }
31220 arg1 = reinterpret_cast< wxWindow * >(argp1);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 resultobj = SWIG_Py_Void();
31228 if (SWIG_IsTmpObj(res2)) {
31229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31230 } else {
31231 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31233 }
31234 if (SWIG_IsTmpObj(res3)) {
31235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31236 } else {
31237 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31239 }
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 PyObject *resultobj = 0;
31248 wxWindow *arg1 = (wxWindow *) 0 ;
31249 void *argp1 = 0 ;
31250 int res1 = 0 ;
31251 PyObject *swig_obj[1] ;
31252
31253 if (!args) SWIG_fail;
31254 swig_obj[0] = args;
31255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31256 if (!SWIG_IsOK(res1)) {
31257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31258 }
31259 arg1 = reinterpret_cast< wxWindow * >(argp1);
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 (arg1)->InvalidateBestSize();
31263 wxPyEndAllowThreads(__tstate);
31264 if (PyErr_Occurred()) SWIG_fail;
31265 }
31266 resultobj = SWIG_Py_Void();
31267 return resultobj;
31268 fail:
31269 return NULL;
31270 }
31271
31272
31273 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31274 PyObject *resultobj = 0;
31275 wxWindow *arg1 = (wxWindow *) 0 ;
31276 wxSize *arg2 = 0 ;
31277 void *argp1 = 0 ;
31278 int res1 = 0 ;
31279 wxSize temp2 ;
31280 PyObject * obj0 = 0 ;
31281 PyObject * obj1 = 0 ;
31282 char * kwnames[] = {
31283 (char *) "self",(char *) "size", NULL
31284 };
31285
31286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31290 }
31291 arg1 = reinterpret_cast< wxWindow * >(argp1);
31292 {
31293 arg2 = &temp2;
31294 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31295 }
31296 {
31297 PyThreadState* __tstate = wxPyBeginAllowThreads();
31298 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 resultobj = SWIG_Py_Void();
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31310 PyObject *resultobj = 0;
31311 wxWindow *arg1 = (wxWindow *) 0 ;
31312 wxSize result;
31313 void *argp1 = 0 ;
31314 int res1 = 0 ;
31315 PyObject *swig_obj[1] ;
31316
31317 if (!args) SWIG_fail;
31318 swig_obj[0] = args;
31319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31322 }
31323 arg1 = reinterpret_cast< wxWindow * >(argp1);
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31338 PyObject *resultobj = 0;
31339 wxWindow *arg1 = (wxWindow *) 0 ;
31340 wxSize result;
31341 void *argp1 = 0 ;
31342 int res1 = 0 ;
31343 PyObject *swig_obj[1] ;
31344
31345 if (!args) SWIG_fail;
31346 swig_obj[0] = args;
31347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31348 if (!SWIG_IsOK(res1)) {
31349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31350 }
31351 arg1 = reinterpret_cast< wxWindow * >(argp1);
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31366 PyObject *resultobj = 0;
31367 wxWindow *arg1 = (wxWindow *) 0 ;
31368 int arg2 = (int) wxBOTH ;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 int val2 ;
31372 int ecode2 = 0 ;
31373 PyObject * obj0 = 0 ;
31374 PyObject * obj1 = 0 ;
31375 char * kwnames[] = {
31376 (char *) "self",(char *) "direction", NULL
31377 };
31378
31379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31381 if (!SWIG_IsOK(res1)) {
31382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31383 }
31384 arg1 = reinterpret_cast< wxWindow * >(argp1);
31385 if (obj1) {
31386 ecode2 = SWIG_AsVal_int(obj1, &val2);
31387 if (!SWIG_IsOK(ecode2)) {
31388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31389 }
31390 arg2 = static_cast< int >(val2);
31391 }
31392 {
31393 PyThreadState* __tstate = wxPyBeginAllowThreads();
31394 (arg1)->Center(arg2);
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 resultobj = SWIG_Py_Void();
31399 return resultobj;
31400 fail:
31401 return NULL;
31402 }
31403
31404
31405 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31406 PyObject *resultobj = 0;
31407 wxWindow *arg1 = (wxWindow *) 0 ;
31408 int arg2 = (int) wxBOTH ;
31409 void *argp1 = 0 ;
31410 int res1 = 0 ;
31411 int val2 ;
31412 int ecode2 = 0 ;
31413 PyObject * obj0 = 0 ;
31414 PyObject * obj1 = 0 ;
31415 char * kwnames[] = {
31416 (char *) "self",(char *) "dir", NULL
31417 };
31418
31419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31421 if (!SWIG_IsOK(res1)) {
31422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31423 }
31424 arg1 = reinterpret_cast< wxWindow * >(argp1);
31425 if (obj1) {
31426 ecode2 = SWIG_AsVal_int(obj1, &val2);
31427 if (!SWIG_IsOK(ecode2)) {
31428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31429 }
31430 arg2 = static_cast< int >(val2);
31431 }
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 (arg1)->CenterOnParent(arg2);
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_Py_Void();
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 wxWindow *arg1 = (wxWindow *) 0 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 PyObject *swig_obj[1] ;
31451
31452 if (!args) SWIG_fail;
31453 swig_obj[0] = args;
31454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31455 if (!SWIG_IsOK(res1)) {
31456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31457 }
31458 arg1 = reinterpret_cast< wxWindow * >(argp1);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 (arg1)->Fit();
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_Py_Void();
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31473 PyObject *resultobj = 0;
31474 wxWindow *arg1 = (wxWindow *) 0 ;
31475 void *argp1 = 0 ;
31476 int res1 = 0 ;
31477 PyObject *swig_obj[1] ;
31478
31479 if (!args) SWIG_fail;
31480 swig_obj[0] = args;
31481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31482 if (!SWIG_IsOK(res1)) {
31483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31484 }
31485 arg1 = reinterpret_cast< wxWindow * >(argp1);
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 (arg1)->FitInside();
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_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31500 PyObject *resultobj = 0;
31501 wxWindow *arg1 = (wxWindow *) 0 ;
31502 int arg2 ;
31503 int arg3 ;
31504 int arg4 = (int) -1 ;
31505 int arg5 = (int) -1 ;
31506 int arg6 = (int) -1 ;
31507 int arg7 = (int) -1 ;
31508 void *argp1 = 0 ;
31509 int res1 = 0 ;
31510 int val2 ;
31511 int ecode2 = 0 ;
31512 int val3 ;
31513 int ecode3 = 0 ;
31514 int val4 ;
31515 int ecode4 = 0 ;
31516 int val5 ;
31517 int ecode5 = 0 ;
31518 int val6 ;
31519 int ecode6 = 0 ;
31520 int val7 ;
31521 int ecode7 = 0 ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 PyObject * obj2 = 0 ;
31525 PyObject * obj3 = 0 ;
31526 PyObject * obj4 = 0 ;
31527 PyObject * obj5 = 0 ;
31528 PyObject * obj6 = 0 ;
31529 char * kwnames[] = {
31530 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31531 };
31532
31533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31535 if (!SWIG_IsOK(res1)) {
31536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31537 }
31538 arg1 = reinterpret_cast< wxWindow * >(argp1);
31539 ecode2 = SWIG_AsVal_int(obj1, &val2);
31540 if (!SWIG_IsOK(ecode2)) {
31541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31542 }
31543 arg2 = static_cast< int >(val2);
31544 ecode3 = SWIG_AsVal_int(obj2, &val3);
31545 if (!SWIG_IsOK(ecode3)) {
31546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31547 }
31548 arg3 = static_cast< int >(val3);
31549 if (obj3) {
31550 ecode4 = SWIG_AsVal_int(obj3, &val4);
31551 if (!SWIG_IsOK(ecode4)) {
31552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31553 }
31554 arg4 = static_cast< int >(val4);
31555 }
31556 if (obj4) {
31557 ecode5 = SWIG_AsVal_int(obj4, &val5);
31558 if (!SWIG_IsOK(ecode5)) {
31559 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31560 }
31561 arg5 = static_cast< int >(val5);
31562 }
31563 if (obj5) {
31564 ecode6 = SWIG_AsVal_int(obj5, &val6);
31565 if (!SWIG_IsOK(ecode6)) {
31566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31567 }
31568 arg6 = static_cast< int >(val6);
31569 }
31570 if (obj6) {
31571 ecode7 = SWIG_AsVal_int(obj6, &val7);
31572 if (!SWIG_IsOK(ecode7)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31574 }
31575 arg7 = static_cast< int >(val7);
31576 }
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_Py_Void();
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 wxSize *arg2 = 0 ;
31594 wxSize const &arg3_defvalue = wxDefaultSize ;
31595 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31596 wxSize const &arg4_defvalue = wxDefaultSize ;
31597 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31598 void *argp1 = 0 ;
31599 int res1 = 0 ;
31600 wxSize temp2 ;
31601 wxSize temp3 ;
31602 wxSize temp4 ;
31603 PyObject * obj0 = 0 ;
31604 PyObject * obj1 = 0 ;
31605 PyObject * obj2 = 0 ;
31606 PyObject * obj3 = 0 ;
31607 char * kwnames[] = {
31608 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31609 };
31610
31611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31615 }
31616 arg1 = reinterpret_cast< wxWindow * >(argp1);
31617 {
31618 arg2 = &temp2;
31619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31620 }
31621 if (obj2) {
31622 {
31623 arg3 = &temp3;
31624 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31625 }
31626 }
31627 if (obj3) {
31628 {
31629 arg4 = &temp4;
31630 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31631 }
31632 }
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 resultobj = SWIG_Py_Void();
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31647 PyObject *resultobj = 0;
31648 wxWindow *arg1 = (wxWindow *) 0 ;
31649 int arg2 ;
31650 int arg3 ;
31651 int arg4 = (int) -1 ;
31652 int arg5 = (int) -1 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 int val2 ;
31656 int ecode2 = 0 ;
31657 int val3 ;
31658 int ecode3 = 0 ;
31659 int val4 ;
31660 int ecode4 = 0 ;
31661 int val5 ;
31662 int ecode5 = 0 ;
31663 PyObject * obj0 = 0 ;
31664 PyObject * obj1 = 0 ;
31665 PyObject * obj2 = 0 ;
31666 PyObject * obj3 = 0 ;
31667 PyObject * obj4 = 0 ;
31668 char * kwnames[] = {
31669 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31670 };
31671
31672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31674 if (!SWIG_IsOK(res1)) {
31675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31676 }
31677 arg1 = reinterpret_cast< wxWindow * >(argp1);
31678 ecode2 = SWIG_AsVal_int(obj1, &val2);
31679 if (!SWIG_IsOK(ecode2)) {
31680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31681 }
31682 arg2 = static_cast< int >(val2);
31683 ecode3 = SWIG_AsVal_int(obj2, &val3);
31684 if (!SWIG_IsOK(ecode3)) {
31685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31686 }
31687 arg3 = static_cast< int >(val3);
31688 if (obj3) {
31689 ecode4 = SWIG_AsVal_int(obj3, &val4);
31690 if (!SWIG_IsOK(ecode4)) {
31691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31692 }
31693 arg4 = static_cast< int >(val4);
31694 }
31695 if (obj4) {
31696 ecode5 = SWIG_AsVal_int(obj4, &val5);
31697 if (!SWIG_IsOK(ecode5)) {
31698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31699 }
31700 arg5 = static_cast< int >(val5);
31701 }
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_Py_Void();
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 wxSize *arg2 = 0 ;
31719 wxSize const &arg3_defvalue = wxDefaultSize ;
31720 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31721 void *argp1 = 0 ;
31722 int res1 = 0 ;
31723 wxSize temp2 ;
31724 wxSize temp3 ;
31725 PyObject * obj0 = 0 ;
31726 PyObject * obj1 = 0 ;
31727 PyObject * obj2 = 0 ;
31728 char * kwnames[] = {
31729 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31730 };
31731
31732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31734 if (!SWIG_IsOK(res1)) {
31735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31736 }
31737 arg1 = reinterpret_cast< wxWindow * >(argp1);
31738 {
31739 arg2 = &temp2;
31740 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31741 }
31742 if (obj2) {
31743 {
31744 arg3 = &temp3;
31745 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31746 }
31747 }
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 resultobj = SWIG_Py_Void();
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *resultobj = 0;
31763 wxWindow *arg1 = (wxWindow *) 0 ;
31764 wxSize result;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 PyObject *swig_obj[1] ;
31768
31769 if (!args) SWIG_fail;
31770 swig_obj[0] = args;
31771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31774 }
31775 arg1 = reinterpret_cast< wxWindow * >(argp1);
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = ((wxWindow const *)arg1)->GetMaxSize();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 wxWindow *arg1 = (wxWindow *) 0 ;
31792 wxSize result;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 PyObject *swig_obj[1] ;
31796
31797 if (!args) SWIG_fail;
31798 swig_obj[0] = args;
31799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31800 if (!SWIG_IsOK(res1)) {
31801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31802 }
31803 arg1 = reinterpret_cast< wxWindow * >(argp1);
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 result = ((wxWindow const *)arg1)->GetMinSize();
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31811 return resultobj;
31812 fail:
31813 return NULL;
31814 }
31815
31816
31817 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31818 PyObject *resultobj = 0;
31819 wxWindow *arg1 = (wxWindow *) 0 ;
31820 wxSize *arg2 = 0 ;
31821 void *argp1 = 0 ;
31822 int res1 = 0 ;
31823 wxSize temp2 ;
31824 PyObject * obj0 = 0 ;
31825 PyObject * obj1 = 0 ;
31826 char * kwnames[] = {
31827 (char *) "self",(char *) "minSize", NULL
31828 };
31829
31830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31834 }
31835 arg1 = reinterpret_cast< wxWindow * >(argp1);
31836 {
31837 arg2 = &temp2;
31838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31839 }
31840 {
31841 PyThreadState* __tstate = wxPyBeginAllowThreads();
31842 (arg1)->SetMinSize((wxSize const &)*arg2);
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 resultobj = SWIG_Py_Void();
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31854 PyObject *resultobj = 0;
31855 wxWindow *arg1 = (wxWindow *) 0 ;
31856 wxSize *arg2 = 0 ;
31857 void *argp1 = 0 ;
31858 int res1 = 0 ;
31859 wxSize temp2 ;
31860 PyObject * obj0 = 0 ;
31861 PyObject * obj1 = 0 ;
31862 char * kwnames[] = {
31863 (char *) "self",(char *) "maxSize", NULL
31864 };
31865
31866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31870 }
31871 arg1 = reinterpret_cast< wxWindow * >(argp1);
31872 {
31873 arg2 = &temp2;
31874 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31875 }
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 (arg1)->SetMaxSize((wxSize const &)*arg2);
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 resultobj = SWIG_Py_Void();
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31890 PyObject *resultobj = 0;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 int result;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 PyObject *swig_obj[1] ;
31896
31897 if (!args) SWIG_fail;
31898 swig_obj[0] = args;
31899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31900 if (!SWIG_IsOK(res1)) {
31901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31902 }
31903 arg1 = reinterpret_cast< wxWindow * >(argp1);
31904 {
31905 PyThreadState* __tstate = wxPyBeginAllowThreads();
31906 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31907 wxPyEndAllowThreads(__tstate);
31908 if (PyErr_Occurred()) SWIG_fail;
31909 }
31910 resultobj = SWIG_From_int(static_cast< int >(result));
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31918 PyObject *resultobj = 0;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 int result;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 PyObject *swig_obj[1] ;
31924
31925 if (!args) SWIG_fail;
31926 swig_obj[0] = args;
31927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31930 }
31931 arg1 = reinterpret_cast< wxWindow * >(argp1);
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31935 wxPyEndAllowThreads(__tstate);
31936 if (PyErr_Occurred()) SWIG_fail;
31937 }
31938 resultobj = SWIG_From_int(static_cast< int >(result));
31939 return resultobj;
31940 fail:
31941 return NULL;
31942 }
31943
31944
31945 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31946 PyObject *resultobj = 0;
31947 wxWindow *arg1 = (wxWindow *) 0 ;
31948 int result;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951 PyObject *swig_obj[1] ;
31952
31953 if (!args) SWIG_fail;
31954 swig_obj[0] = args;
31955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_From_int(static_cast< int >(result));
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *resultobj = 0;
31975 wxWindow *arg1 = (wxWindow *) 0 ;
31976 int result;
31977 void *argp1 = 0 ;
31978 int res1 = 0 ;
31979 PyObject *swig_obj[1] ;
31980
31981 if (!args) SWIG_fail;
31982 swig_obj[0] = args;
31983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31984 if (!SWIG_IsOK(res1)) {
31985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 {
31989 PyThreadState* __tstate = wxPyBeginAllowThreads();
31990 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_From_int(static_cast< int >(result));
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32002 PyObject *resultobj = 0;
32003 wxWindow *arg1 = (wxWindow *) 0 ;
32004 wxSize *arg2 = 0 ;
32005 void *argp1 = 0 ;
32006 int res1 = 0 ;
32007 wxSize temp2 ;
32008 PyObject * obj0 = 0 ;
32009 PyObject * obj1 = 0 ;
32010 char * kwnames[] = {
32011 (char *) "self",(char *) "size", NULL
32012 };
32013
32014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32016 if (!SWIG_IsOK(res1)) {
32017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32018 }
32019 arg1 = reinterpret_cast< wxWindow * >(argp1);
32020 {
32021 arg2 = &temp2;
32022 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32023 }
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_Py_Void();
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 int arg2 ;
32041 int arg3 ;
32042 void *argp1 = 0 ;
32043 int res1 = 0 ;
32044 int val2 ;
32045 int ecode2 = 0 ;
32046 int val3 ;
32047 int ecode3 = 0 ;
32048 PyObject * obj0 = 0 ;
32049 PyObject * obj1 = 0 ;
32050 PyObject * obj2 = 0 ;
32051 char * kwnames[] = {
32052 (char *) "self",(char *) "w",(char *) "h", NULL
32053 };
32054
32055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32057 if (!SWIG_IsOK(res1)) {
32058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32059 }
32060 arg1 = reinterpret_cast< wxWindow * >(argp1);
32061 ecode2 = SWIG_AsVal_int(obj1, &val2);
32062 if (!SWIG_IsOK(ecode2)) {
32063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32064 }
32065 arg2 = static_cast< int >(val2);
32066 ecode3 = SWIG_AsVal_int(obj2, &val3);
32067 if (!SWIG_IsOK(ecode3)) {
32068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32069 }
32070 arg3 = static_cast< int >(val3);
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 (arg1)->SetVirtualSize(arg2,arg3);
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 resultobj = SWIG_Py_Void();
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 PyObject *resultobj = 0;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 wxSize result;
32088 void *argp1 = 0 ;
32089 int res1 = 0 ;
32090 PyObject *swig_obj[1] ;
32091
32092 if (!args) SWIG_fail;
32093 swig_obj[0] = args;
32094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32097 }
32098 arg1 = reinterpret_cast< wxWindow * >(argp1);
32099 {
32100 PyThreadState* __tstate = wxPyBeginAllowThreads();
32101 result = ((wxWindow const *)arg1)->GetVirtualSize();
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 wxWindow *arg1 = (wxWindow *) 0 ;
32115 int *arg2 = (int *) 0 ;
32116 int *arg3 = (int *) 0 ;
32117 void *argp1 = 0 ;
32118 int res1 = 0 ;
32119 int temp2 ;
32120 int res2 = SWIG_TMPOBJ ;
32121 int temp3 ;
32122 int res3 = SWIG_TMPOBJ ;
32123 PyObject *swig_obj[1] ;
32124
32125 arg2 = &temp2;
32126 arg3 = &temp3;
32127 if (!args) SWIG_fail;
32128 swig_obj[0] = args;
32129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32130 if (!SWIG_IsOK(res1)) {
32131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32132 }
32133 arg1 = reinterpret_cast< wxWindow * >(argp1);
32134 {
32135 PyThreadState* __tstate = wxPyBeginAllowThreads();
32136 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32137 wxPyEndAllowThreads(__tstate);
32138 if (PyErr_Occurred()) SWIG_fail;
32139 }
32140 resultobj = SWIG_Py_Void();
32141 if (SWIG_IsTmpObj(res2)) {
32142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32143 } else {
32144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32146 }
32147 if (SWIG_IsTmpObj(res3)) {
32148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32149 } else {
32150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32152 }
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 wxSize result;
32163 void *argp1 = 0 ;
32164 int res1 = 0 ;
32165 PyObject *swig_obj[1] ;
32166
32167 if (!args) SWIG_fail;
32168 swig_obj[0] = args;
32169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32170 if (!SWIG_IsOK(res1)) {
32171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 {
32175 PyThreadState* __tstate = wxPyBeginAllowThreads();
32176 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32188 PyObject *resultobj = 0;
32189 wxWindow *arg1 = (wxWindow *) 0 ;
32190 bool arg2 = (bool) true ;
32191 bool result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 bool val2 ;
32195 int ecode2 = 0 ;
32196 PyObject * obj0 = 0 ;
32197 PyObject * obj1 = 0 ;
32198 char * kwnames[] = {
32199 (char *) "self",(char *) "show", NULL
32200 };
32201
32202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32204 if (!SWIG_IsOK(res1)) {
32205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32206 }
32207 arg1 = reinterpret_cast< wxWindow * >(argp1);
32208 if (obj1) {
32209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32210 if (!SWIG_IsOK(ecode2)) {
32211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32212 }
32213 arg2 = static_cast< bool >(val2);
32214 }
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (bool)(arg1)->Show(arg2);
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32223 }
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 PyObject *resultobj = 0;
32232 wxWindow *arg1 = (wxWindow *) 0 ;
32233 bool result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 PyObject *swig_obj[1] ;
32237
32238 if (!args) SWIG_fail;
32239 swig_obj[0] = args;
32240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32243 }
32244 arg1 = reinterpret_cast< wxWindow * >(argp1);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (bool)(arg1)->Hide();
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32261 PyObject *resultobj = 0;
32262 wxWindow *arg1 = (wxWindow *) 0 ;
32263 bool arg2 = (bool) true ;
32264 bool result;
32265 void *argp1 = 0 ;
32266 int res1 = 0 ;
32267 bool val2 ;
32268 int ecode2 = 0 ;
32269 PyObject * obj0 = 0 ;
32270 PyObject * obj1 = 0 ;
32271 char * kwnames[] = {
32272 (char *) "self",(char *) "enable", NULL
32273 };
32274
32275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32279 }
32280 arg1 = reinterpret_cast< wxWindow * >(argp1);
32281 if (obj1) {
32282 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32283 if (!SWIG_IsOK(ecode2)) {
32284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32285 }
32286 arg2 = static_cast< bool >(val2);
32287 }
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (bool)(arg1)->Enable(arg2);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 {
32295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32296 }
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32304 PyObject *resultobj = 0;
32305 wxWindow *arg1 = (wxWindow *) 0 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 PyObject *swig_obj[1] ;
32310
32311 if (!args) SWIG_fail;
32312 swig_obj[0] = args;
32313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32314 if (!SWIG_IsOK(res1)) {
32315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32316 }
32317 arg1 = reinterpret_cast< wxWindow * >(argp1);
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 result = (bool)(arg1)->Disable();
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 {
32325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32326 }
32327 return resultobj;
32328 fail:
32329 return NULL;
32330 }
32331
32332
32333 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32334 PyObject *resultobj = 0;
32335 wxWindow *arg1 = (wxWindow *) 0 ;
32336 bool result;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 PyObject *swig_obj[1] ;
32340
32341 if (!args) SWIG_fail;
32342 swig_obj[0] = args;
32343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32344 if (!SWIG_IsOK(res1)) {
32345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32346 }
32347 arg1 = reinterpret_cast< wxWindow * >(argp1);
32348 {
32349 PyThreadState* __tstate = wxPyBeginAllowThreads();
32350 result = (bool)((wxWindow const *)arg1)->IsShown();
32351 wxPyEndAllowThreads(__tstate);
32352 if (PyErr_Occurred()) SWIG_fail;
32353 }
32354 {
32355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32356 }
32357 return resultobj;
32358 fail:
32359 return NULL;
32360 }
32361
32362
32363 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32364 PyObject *resultobj = 0;
32365 wxWindow *arg1 = (wxWindow *) 0 ;
32366 bool result;
32367 void *argp1 = 0 ;
32368 int res1 = 0 ;
32369 PyObject *swig_obj[1] ;
32370
32371 if (!args) SWIG_fail;
32372 swig_obj[0] = args;
32373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32374 if (!SWIG_IsOK(res1)) {
32375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32376 }
32377 arg1 = reinterpret_cast< wxWindow * >(argp1);
32378 {
32379 PyThreadState* __tstate = wxPyBeginAllowThreads();
32380 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32381 wxPyEndAllowThreads(__tstate);
32382 if (PyErr_Occurred()) SWIG_fail;
32383 }
32384 {
32385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32386 }
32387 return resultobj;
32388 fail:
32389 return NULL;
32390 }
32391
32392
32393 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32394 PyObject *resultobj = 0;
32395 wxWindow *arg1 = (wxWindow *) 0 ;
32396 long arg2 ;
32397 void *argp1 = 0 ;
32398 int res1 = 0 ;
32399 long val2 ;
32400 int ecode2 = 0 ;
32401 PyObject * obj0 = 0 ;
32402 PyObject * obj1 = 0 ;
32403 char * kwnames[] = {
32404 (char *) "self",(char *) "style", NULL
32405 };
32406
32407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32409 if (!SWIG_IsOK(res1)) {
32410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32411 }
32412 arg1 = reinterpret_cast< wxWindow * >(argp1);
32413 ecode2 = SWIG_AsVal_long(obj1, &val2);
32414 if (!SWIG_IsOK(ecode2)) {
32415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32416 }
32417 arg2 = static_cast< long >(val2);
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 (arg1)->SetWindowStyleFlag(arg2);
32421 wxPyEndAllowThreads(__tstate);
32422 if (PyErr_Occurred()) SWIG_fail;
32423 }
32424 resultobj = SWIG_Py_Void();
32425 return resultobj;
32426 fail:
32427 return NULL;
32428 }
32429
32430
32431 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32432 PyObject *resultobj = 0;
32433 wxWindow *arg1 = (wxWindow *) 0 ;
32434 long result;
32435 void *argp1 = 0 ;
32436 int res1 = 0 ;
32437 PyObject *swig_obj[1] ;
32438
32439 if (!args) SWIG_fail;
32440 swig_obj[0] = args;
32441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32442 if (!SWIG_IsOK(res1)) {
32443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32444 }
32445 arg1 = reinterpret_cast< wxWindow * >(argp1);
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32449 wxPyEndAllowThreads(__tstate);
32450 if (PyErr_Occurred()) SWIG_fail;
32451 }
32452 resultobj = SWIG_From_long(static_cast< long >(result));
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32460 PyObject *resultobj = 0;
32461 wxWindow *arg1 = (wxWindow *) 0 ;
32462 int arg2 ;
32463 bool result;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 int val2 ;
32467 int ecode2 = 0 ;
32468 PyObject * obj0 = 0 ;
32469 PyObject * obj1 = 0 ;
32470 char * kwnames[] = {
32471 (char *) "self",(char *) "flag", NULL
32472 };
32473
32474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32476 if (!SWIG_IsOK(res1)) {
32477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32478 }
32479 arg1 = reinterpret_cast< wxWindow * >(argp1);
32480 ecode2 = SWIG_AsVal_int(obj1, &val2);
32481 if (!SWIG_IsOK(ecode2)) {
32482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32483 }
32484 arg2 = static_cast< int >(val2);
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 {
32492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 bool result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)((wxWindow const *)arg1)->IsRetained();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32531 PyObject *resultobj = 0;
32532 wxWindow *arg1 = (wxWindow *) 0 ;
32533 long arg2 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 long val2 ;
32537 int ecode2 = 0 ;
32538 PyObject * obj0 = 0 ;
32539 PyObject * obj1 = 0 ;
32540 char * kwnames[] = {
32541 (char *) "self",(char *) "exStyle", NULL
32542 };
32543
32544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32546 if (!SWIG_IsOK(res1)) {
32547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32548 }
32549 arg1 = reinterpret_cast< wxWindow * >(argp1);
32550 ecode2 = SWIG_AsVal_long(obj1, &val2);
32551 if (!SWIG_IsOK(ecode2)) {
32552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32553 }
32554 arg2 = static_cast< long >(val2);
32555 {
32556 PyThreadState* __tstate = wxPyBeginAllowThreads();
32557 (arg1)->SetExtraStyle(arg2);
32558 wxPyEndAllowThreads(__tstate);
32559 if (PyErr_Occurred()) SWIG_fail;
32560 }
32561 resultobj = SWIG_Py_Void();
32562 return resultobj;
32563 fail:
32564 return NULL;
32565 }
32566
32567
32568 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32569 PyObject *resultobj = 0;
32570 wxWindow *arg1 = (wxWindow *) 0 ;
32571 long result;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 PyObject *swig_obj[1] ;
32575
32576 if (!args) SWIG_fail;
32577 swig_obj[0] = args;
32578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32579 if (!SWIG_IsOK(res1)) {
32580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32581 }
32582 arg1 = reinterpret_cast< wxWindow * >(argp1);
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 resultobj = SWIG_From_long(static_cast< long >(result));
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32597 PyObject *resultobj = 0;
32598 wxWindow *arg1 = (wxWindow *) 0 ;
32599 bool arg2 = (bool) true ;
32600 void *argp1 = 0 ;
32601 int res1 = 0 ;
32602 bool val2 ;
32603 int ecode2 = 0 ;
32604 PyObject * obj0 = 0 ;
32605 PyObject * obj1 = 0 ;
32606 char * kwnames[] = {
32607 (char *) "self",(char *) "modal", NULL
32608 };
32609
32610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32612 if (!SWIG_IsOK(res1)) {
32613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32614 }
32615 arg1 = reinterpret_cast< wxWindow * >(argp1);
32616 if (obj1) {
32617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32618 if (!SWIG_IsOK(ecode2)) {
32619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32620 }
32621 arg2 = static_cast< bool >(val2);
32622 }
32623 {
32624 PyThreadState* __tstate = wxPyBeginAllowThreads();
32625 (arg1)->MakeModal(arg2);
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32637 PyObject *resultobj = 0;
32638 wxWindow *arg1 = (wxWindow *) 0 ;
32639 bool arg2 ;
32640 void *argp1 = 0 ;
32641 int res1 = 0 ;
32642 bool val2 ;
32643 int ecode2 = 0 ;
32644 PyObject * obj0 = 0 ;
32645 PyObject * obj1 = 0 ;
32646 char * kwnames[] = {
32647 (char *) "self",(char *) "enableTheme", NULL
32648 };
32649
32650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32652 if (!SWIG_IsOK(res1)) {
32653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32654 }
32655 arg1 = reinterpret_cast< wxWindow * >(argp1);
32656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32657 if (!SWIG_IsOK(ecode2)) {
32658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32659 }
32660 arg2 = static_cast< bool >(val2);
32661 {
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 (arg1)->SetThemeEnabled(arg2);
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 resultobj = SWIG_Py_Void();
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32675 PyObject *resultobj = 0;
32676 wxWindow *arg1 = (wxWindow *) 0 ;
32677 bool result;
32678 void *argp1 = 0 ;
32679 int res1 = 0 ;
32680 PyObject *swig_obj[1] ;
32681
32682 if (!args) SWIG_fail;
32683 swig_obj[0] = args;
32684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32687 }
32688 arg1 = reinterpret_cast< wxWindow * >(argp1);
32689 {
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32692 wxPyEndAllowThreads(__tstate);
32693 if (PyErr_Occurred()) SWIG_fail;
32694 }
32695 {
32696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32697 }
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32705 PyObject *resultobj = 0;
32706 wxWindow *arg1 = (wxWindow *) 0 ;
32707 void *argp1 = 0 ;
32708 int res1 = 0 ;
32709 PyObject *swig_obj[1] ;
32710
32711 if (!args) SWIG_fail;
32712 swig_obj[0] = args;
32713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32714 if (!SWIG_IsOK(res1)) {
32715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32716 }
32717 arg1 = reinterpret_cast< wxWindow * >(argp1);
32718 {
32719 PyThreadState* __tstate = wxPyBeginAllowThreads();
32720 (arg1)->SetFocus();
32721 wxPyEndAllowThreads(__tstate);
32722 if (PyErr_Occurred()) SWIG_fail;
32723 }
32724 resultobj = SWIG_Py_Void();
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32732 PyObject *resultobj = 0;
32733 wxWindow *arg1 = (wxWindow *) 0 ;
32734 void *argp1 = 0 ;
32735 int res1 = 0 ;
32736 PyObject *swig_obj[1] ;
32737
32738 if (!args) SWIG_fail;
32739 swig_obj[0] = args;
32740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32741 if (!SWIG_IsOK(res1)) {
32742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32743 }
32744 arg1 = reinterpret_cast< wxWindow * >(argp1);
32745 {
32746 PyThreadState* __tstate = wxPyBeginAllowThreads();
32747 (arg1)->SetFocusFromKbd();
32748 wxPyEndAllowThreads(__tstate);
32749 if (PyErr_Occurred()) SWIG_fail;
32750 }
32751 resultobj = SWIG_Py_Void();
32752 return resultobj;
32753 fail:
32754 return NULL;
32755 }
32756
32757
32758 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32759 PyObject *resultobj = 0;
32760 wxWindow *result = 0 ;
32761
32762 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32763 {
32764 if (!wxPyCheckForApp()) SWIG_fail;
32765 PyThreadState* __tstate = wxPyBeginAllowThreads();
32766 result = (wxWindow *)wxWindow::FindFocus();
32767 wxPyEndAllowThreads(__tstate);
32768 if (PyErr_Occurred()) SWIG_fail;
32769 }
32770 {
32771 resultobj = wxPyMake_wxObject(result, 0);
32772 }
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxWindow *arg1 = (wxWindow *) 0 ;
32782 bool result;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32792 }
32793 arg1 = reinterpret_cast< wxWindow * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 {
32801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32802 }
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32810 PyObject *resultobj = 0;
32811 wxWindow *arg1 = (wxWindow *) 0 ;
32812 bool result;
32813 void *argp1 = 0 ;
32814 int res1 = 0 ;
32815 PyObject *swig_obj[1] ;
32816
32817 if (!args) SWIG_fail;
32818 swig_obj[0] = args;
32819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32822 }
32823 arg1 = reinterpret_cast< wxWindow * >(argp1);
32824 {
32825 PyThreadState* __tstate = wxPyBeginAllowThreads();
32826 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32827 wxPyEndAllowThreads(__tstate);
32828 if (PyErr_Occurred()) SWIG_fail;
32829 }
32830 {
32831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32832 }
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32840 PyObject *resultobj = 0;
32841 wxWindow *arg1 = (wxWindow *) 0 ;
32842 wxWindow *result = 0 ;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 PyObject *swig_obj[1] ;
32846
32847 if (!args) SWIG_fail;
32848 swig_obj[0] = args;
32849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32852 }
32853 arg1 = reinterpret_cast< wxWindow * >(argp1);
32854 {
32855 PyThreadState* __tstate = wxPyBeginAllowThreads();
32856 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 {
32861 resultobj = wxPyMake_wxObject(result, 0);
32862 }
32863 return resultobj;
32864 fail:
32865 return NULL;
32866 }
32867
32868
32869 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32870 PyObject *resultobj = 0;
32871 wxWindow *arg1 = (wxWindow *) 0 ;
32872 wxWindow *arg2 = (wxWindow *) 0 ;
32873 wxWindow *result = 0 ;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 void *argp2 = 0 ;
32877 int res2 = 0 ;
32878 PyObject * obj0 = 0 ;
32879 PyObject * obj1 = 0 ;
32880 char * kwnames[] = {
32881 (char *) "self",(char *) "child", NULL
32882 };
32883
32884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32886 if (!SWIG_IsOK(res1)) {
32887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32888 }
32889 arg1 = reinterpret_cast< wxWindow * >(argp1);
32890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32891 if (!SWIG_IsOK(res2)) {
32892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32893 }
32894 arg2 = reinterpret_cast< wxWindow * >(argp2);
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32898 wxPyEndAllowThreads(__tstate);
32899 if (PyErr_Occurred()) SWIG_fail;
32900 }
32901 {
32902 resultobj = wxPyMake_wxObject(result, 0);
32903 }
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(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 *) "win", NULL
32922 };
32923
32924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",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_SetTmpDefaultItem" "', 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_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32933 }
32934 arg2 = reinterpret_cast< wxWindow * >(argp2);
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 (arg1)->SetTmpDefaultItem(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_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32949 PyObject *resultobj = 0;
32950 wxWindow *arg1 = (wxWindow *) 0 ;
32951 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32952 bool result;
32953 void *argp1 = 0 ;
32954 int res1 = 0 ;
32955 int val2 ;
32956 int ecode2 = 0 ;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 char * kwnames[] = {
32960 (char *) "self",(char *) "flags", NULL
32961 };
32962
32963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",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_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32967 }
32968 arg1 = reinterpret_cast< wxWindow * >(argp1);
32969 if (obj1) {
32970 ecode2 = SWIG_AsVal_int(obj1, &val2);
32971 if (!SWIG_IsOK(ecode2)) {
32972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32973 }
32974 arg2 = static_cast< int >(val2);
32975 }
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (bool)(arg1)->Navigate(arg2);
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 {
32983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32984 }
32985 return resultobj;
32986 fail:
32987 return NULL;
32988 }
32989
32990
32991 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32992 PyObject *resultobj = 0;
32993 wxWindow *arg1 = (wxWindow *) 0 ;
32994 wxWindow *arg2 = (wxWindow *) 0 ;
32995 void *argp1 = 0 ;
32996 int res1 = 0 ;
32997 void *argp2 = 0 ;
32998 int res2 = 0 ;
32999 PyObject * obj0 = 0 ;
33000 PyObject * obj1 = 0 ;
33001 char * kwnames[] = {
33002 (char *) "self",(char *) "win", NULL
33003 };
33004
33005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res2)) {
33013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33014 }
33015 arg2 = reinterpret_cast< wxWindow * >(argp2);
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 (arg1)->MoveAfterInTabOrder(arg2);
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 resultobj = SWIG_Py_Void();
33023 return resultobj;
33024 fail:
33025 return NULL;
33026 }
33027
33028
33029 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33030 PyObject *resultobj = 0;
33031 wxWindow *arg1 = (wxWindow *) 0 ;
33032 wxWindow *arg2 = (wxWindow *) 0 ;
33033 void *argp1 = 0 ;
33034 int res1 = 0 ;
33035 void *argp2 = 0 ;
33036 int res2 = 0 ;
33037 PyObject * obj0 = 0 ;
33038 PyObject * obj1 = 0 ;
33039 char * kwnames[] = {
33040 (char *) "self",(char *) "win", NULL
33041 };
33042
33043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33047 }
33048 arg1 = reinterpret_cast< wxWindow * >(argp1);
33049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33050 if (!SWIG_IsOK(res2)) {
33051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33052 }
33053 arg2 = reinterpret_cast< wxWindow * >(argp2);
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 (arg1)->MoveBeforeInTabOrder(arg2);
33057 wxPyEndAllowThreads(__tstate);
33058 if (PyErr_Occurred()) SWIG_fail;
33059 }
33060 resultobj = SWIG_Py_Void();
33061 return resultobj;
33062 fail:
33063 return NULL;
33064 }
33065
33066
33067 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33068 PyObject *resultobj = 0;
33069 wxWindow *arg1 = (wxWindow *) 0 ;
33070 PyObject *result = 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 PyObject *swig_obj[1] ;
33074
33075 if (!args) SWIG_fail;
33076 swig_obj[0] = args;
33077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33078 if (!SWIG_IsOK(res1)) {
33079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33080 }
33081 arg1 = reinterpret_cast< wxWindow * >(argp1);
33082 {
33083 PyThreadState* __tstate = wxPyBeginAllowThreads();
33084 result = (PyObject *)wxWindow_GetChildren(arg1);
33085 wxPyEndAllowThreads(__tstate);
33086 if (PyErr_Occurred()) SWIG_fail;
33087 }
33088 resultobj = result;
33089 return resultobj;
33090 fail:
33091 return NULL;
33092 }
33093
33094
33095 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33096 PyObject *resultobj = 0;
33097 wxWindow *arg1 = (wxWindow *) 0 ;
33098 wxWindow *result = 0 ;
33099 void *argp1 = 0 ;
33100 int res1 = 0 ;
33101 PyObject *swig_obj[1] ;
33102
33103 if (!args) SWIG_fail;
33104 swig_obj[0] = args;
33105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 {
33117 resultobj = wxPyMake_wxObject(result, 0);
33118 }
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxWindow *result = 0 ;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 PyObject *swig_obj[1] ;
33132
33133 if (!args) SWIG_fail;
33134 swig_obj[0] = args;
33135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33136 if (!SWIG_IsOK(res1)) {
33137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33138 }
33139 arg1 = reinterpret_cast< wxWindow * >(argp1);
33140 {
33141 PyThreadState* __tstate = wxPyBeginAllowThreads();
33142 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 {
33147 resultobj = wxPyMake_wxObject(result, 0);
33148 }
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33156 PyObject *resultobj = 0;
33157 wxWindow *arg1 = (wxWindow *) 0 ;
33158 bool result;
33159 void *argp1 = 0 ;
33160 int res1 = 0 ;
33161 PyObject *swig_obj[1] ;
33162
33163 if (!args) SWIG_fail;
33164 swig_obj[0] = args;
33165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33168 }
33169 arg1 = reinterpret_cast< wxWindow * >(argp1);
33170 {
33171 PyThreadState* __tstate = wxPyBeginAllowThreads();
33172 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 {
33177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33178 }
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33186 PyObject *resultobj = 0;
33187 wxWindow *arg1 = (wxWindow *) 0 ;
33188 wxWindow *arg2 = (wxWindow *) 0 ;
33189 bool result;
33190 void *argp1 = 0 ;
33191 int res1 = 0 ;
33192 void *argp2 = 0 ;
33193 int res2 = 0 ;
33194 PyObject * obj0 = 0 ;
33195 PyObject * obj1 = 0 ;
33196 char * kwnames[] = {
33197 (char *) "self",(char *) "newParent", NULL
33198 };
33199
33200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33204 }
33205 arg1 = reinterpret_cast< wxWindow * >(argp1);
33206 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33207 if (!SWIG_IsOK(res2)) {
33208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33209 }
33210 arg2 = reinterpret_cast< wxWindow * >(argp2);
33211 {
33212 PyThreadState* __tstate = wxPyBeginAllowThreads();
33213 result = (bool)(arg1)->Reparent(arg2);
33214 wxPyEndAllowThreads(__tstate);
33215 if (PyErr_Occurred()) SWIG_fail;
33216 }
33217 {
33218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33219 }
33220 return resultobj;
33221 fail:
33222 return NULL;
33223 }
33224
33225
33226 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33227 PyObject *resultobj = 0;
33228 wxWindow *arg1 = (wxWindow *) 0 ;
33229 wxWindow *arg2 = (wxWindow *) 0 ;
33230 void *argp1 = 0 ;
33231 int res1 = 0 ;
33232 void *argp2 = 0 ;
33233 int res2 = 0 ;
33234 PyObject * obj0 = 0 ;
33235 PyObject * obj1 = 0 ;
33236 char * kwnames[] = {
33237 (char *) "self",(char *) "child", NULL
33238 };
33239
33240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33242 if (!SWIG_IsOK(res1)) {
33243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33244 }
33245 arg1 = reinterpret_cast< wxWindow * >(argp1);
33246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33247 if (!SWIG_IsOK(res2)) {
33248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33249 }
33250 arg2 = reinterpret_cast< wxWindow * >(argp2);
33251 {
33252 PyThreadState* __tstate = wxPyBeginAllowThreads();
33253 (arg1)->AddChild(arg2);
33254 wxPyEndAllowThreads(__tstate);
33255 if (PyErr_Occurred()) SWIG_fail;
33256 }
33257 resultobj = SWIG_Py_Void();
33258 return resultobj;
33259 fail:
33260 return NULL;
33261 }
33262
33263
33264 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj = 0;
33266 wxWindow *arg1 = (wxWindow *) 0 ;
33267 wxWindow *arg2 = (wxWindow *) 0 ;
33268 void *argp1 = 0 ;
33269 int res1 = 0 ;
33270 void *argp2 = 0 ;
33271 int res2 = 0 ;
33272 PyObject * obj0 = 0 ;
33273 PyObject * obj1 = 0 ;
33274 char * kwnames[] = {
33275 (char *) "self",(char *) "child", NULL
33276 };
33277
33278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33280 if (!SWIG_IsOK(res1)) {
33281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33282 }
33283 arg1 = reinterpret_cast< wxWindow * >(argp1);
33284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33285 if (!SWIG_IsOK(res2)) {
33286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33287 }
33288 arg2 = reinterpret_cast< wxWindow * >(argp2);
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 (arg1)->RemoveChild(arg2);
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 resultobj = SWIG_Py_Void();
33296 return resultobj;
33297 fail:
33298 return NULL;
33299 }
33300
33301
33302 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33303 PyObject *resultobj = 0;
33304 wxWindow *arg1 = (wxWindow *) 0 ;
33305 bool arg2 ;
33306 void *argp1 = 0 ;
33307 int res1 = 0 ;
33308 bool val2 ;
33309 int ecode2 = 0 ;
33310 PyObject * obj0 = 0 ;
33311 PyObject * obj1 = 0 ;
33312 char * kwnames[] = {
33313 (char *) "self",(char *) "on", NULL
33314 };
33315
33316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33318 if (!SWIG_IsOK(res1)) {
33319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33320 }
33321 arg1 = reinterpret_cast< wxWindow * >(argp1);
33322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33323 if (!SWIG_IsOK(ecode2)) {
33324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33325 }
33326 arg2 = static_cast< bool >(val2);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 wxWindow_SetDoubleBuffered(arg1,arg2);
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_Py_Void();
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj = 0;
33342 wxWindow *arg1 = (wxWindow *) 0 ;
33343 long arg2 ;
33344 wxWindow *result = 0 ;
33345 void *argp1 = 0 ;
33346 int res1 = 0 ;
33347 long val2 ;
33348 int ecode2 = 0 ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char * kwnames[] = {
33352 (char *) "self",(char *) "winid", NULL
33353 };
33354
33355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33359 }
33360 arg1 = reinterpret_cast< wxWindow * >(argp1);
33361 ecode2 = SWIG_AsVal_long(obj1, &val2);
33362 if (!SWIG_IsOK(ecode2)) {
33363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33364 }
33365 arg2 = static_cast< long >(val2);
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (wxWindow *)(arg1)->FindWindow(arg2);
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 {
33373 resultobj = wxPyMake_wxObject(result, 0);
33374 }
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj = 0;
33383 wxWindow *arg1 = (wxWindow *) 0 ;
33384 wxString *arg2 = 0 ;
33385 wxWindow *result = 0 ;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 bool temp2 = false ;
33389 PyObject * obj0 = 0 ;
33390 PyObject * obj1 = 0 ;
33391 char * kwnames[] = {
33392 (char *) "self",(char *) "name", NULL
33393 };
33394
33395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33397 if (!SWIG_IsOK(res1)) {
33398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33399 }
33400 arg1 = reinterpret_cast< wxWindow * >(argp1);
33401 {
33402 arg2 = wxString_in_helper(obj1);
33403 if (arg2 == NULL) SWIG_fail;
33404 temp2 = true;
33405 }
33406 {
33407 PyThreadState* __tstate = wxPyBeginAllowThreads();
33408 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33409 wxPyEndAllowThreads(__tstate);
33410 if (PyErr_Occurred()) SWIG_fail;
33411 }
33412 {
33413 resultobj = wxPyMake_wxObject(result, 0);
33414 }
33415 {
33416 if (temp2)
33417 delete arg2;
33418 }
33419 return resultobj;
33420 fail:
33421 {
33422 if (temp2)
33423 delete arg2;
33424 }
33425 return NULL;
33426 }
33427
33428
33429 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33430 PyObject *resultobj = 0;
33431 wxWindow *arg1 = (wxWindow *) 0 ;
33432 wxEvtHandler *result = 0 ;
33433 void *argp1 = 0 ;
33434 int res1 = 0 ;
33435 PyObject *swig_obj[1] ;
33436
33437 if (!args) SWIG_fail;
33438 swig_obj[0] = args;
33439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33440 if (!SWIG_IsOK(res1)) {
33441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33442 }
33443 arg1 = reinterpret_cast< wxWindow * >(argp1);
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 {
33451 resultobj = wxPyMake_wxObject(result, 0);
33452 }
33453 return resultobj;
33454 fail:
33455 return NULL;
33456 }
33457
33458
33459 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33460 PyObject *resultobj = 0;
33461 wxWindow *arg1 = (wxWindow *) 0 ;
33462 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33463 void *argp1 = 0 ;
33464 int res1 = 0 ;
33465 void *argp2 = 0 ;
33466 int res2 = 0 ;
33467 PyObject * obj0 = 0 ;
33468 PyObject * obj1 = 0 ;
33469 char * kwnames[] = {
33470 (char *) "self",(char *) "handler", NULL
33471 };
33472
33473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33475 if (!SWIG_IsOK(res1)) {
33476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33477 }
33478 arg1 = reinterpret_cast< wxWindow * >(argp1);
33479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33480 if (!SWIG_IsOK(res2)) {
33481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33482 }
33483 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 (arg1)->SetEventHandler(arg2);
33487 wxPyEndAllowThreads(__tstate);
33488 if (PyErr_Occurred()) SWIG_fail;
33489 }
33490 resultobj = SWIG_Py_Void();
33491 return resultobj;
33492 fail:
33493 return NULL;
33494 }
33495
33496
33497 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33498 PyObject *resultobj = 0;
33499 wxWindow *arg1 = (wxWindow *) 0 ;
33500 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33501 void *argp1 = 0 ;
33502 int res1 = 0 ;
33503 void *argp2 = 0 ;
33504 int res2 = 0 ;
33505 PyObject * obj0 = 0 ;
33506 PyObject * obj1 = 0 ;
33507 char * kwnames[] = {
33508 (char *) "self",(char *) "handler", NULL
33509 };
33510
33511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33513 if (!SWIG_IsOK(res1)) {
33514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33515 }
33516 arg1 = reinterpret_cast< wxWindow * >(argp1);
33517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33518 if (!SWIG_IsOK(res2)) {
33519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33520 }
33521 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33522 {
33523 PyThreadState* __tstate = wxPyBeginAllowThreads();
33524 (arg1)->PushEventHandler(arg2);
33525 wxPyEndAllowThreads(__tstate);
33526 if (PyErr_Occurred()) SWIG_fail;
33527 }
33528 resultobj = SWIG_Py_Void();
33529 return resultobj;
33530 fail:
33531 return NULL;
33532 }
33533
33534
33535 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33536 PyObject *resultobj = 0;
33537 wxWindow *arg1 = (wxWindow *) 0 ;
33538 bool arg2 = (bool) false ;
33539 wxEvtHandler *result = 0 ;
33540 void *argp1 = 0 ;
33541 int res1 = 0 ;
33542 bool val2 ;
33543 int ecode2 = 0 ;
33544 PyObject * obj0 = 0 ;
33545 PyObject * obj1 = 0 ;
33546 char * kwnames[] = {
33547 (char *) "self",(char *) "deleteHandler", NULL
33548 };
33549
33550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33552 if (!SWIG_IsOK(res1)) {
33553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33554 }
33555 arg1 = reinterpret_cast< wxWindow * >(argp1);
33556 if (obj1) {
33557 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33558 if (!SWIG_IsOK(ecode2)) {
33559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33560 }
33561 arg2 = static_cast< bool >(val2);
33562 }
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33566 wxPyEndAllowThreads(__tstate);
33567 if (PyErr_Occurred()) SWIG_fail;
33568 }
33569 {
33570 resultobj = wxPyMake_wxObject(result, 0);
33571 }
33572 return resultobj;
33573 fail:
33574 return NULL;
33575 }
33576
33577
33578 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33579 PyObject *resultobj = 0;
33580 wxWindow *arg1 = (wxWindow *) 0 ;
33581 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33582 bool result;
33583 void *argp1 = 0 ;
33584 int res1 = 0 ;
33585 void *argp2 = 0 ;
33586 int res2 = 0 ;
33587 PyObject * obj0 = 0 ;
33588 PyObject * obj1 = 0 ;
33589 char * kwnames[] = {
33590 (char *) "self",(char *) "handler", NULL
33591 };
33592
33593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33597 }
33598 arg1 = reinterpret_cast< wxWindow * >(argp1);
33599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33600 if (!SWIG_IsOK(res2)) {
33601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33602 }
33603 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33604 {
33605 PyThreadState* __tstate = wxPyBeginAllowThreads();
33606 result = (bool)(arg1)->RemoveEventHandler(arg2);
33607 wxPyEndAllowThreads(__tstate);
33608 if (PyErr_Occurred()) SWIG_fail;
33609 }
33610 {
33611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33612 }
33613 return resultobj;
33614 fail:
33615 return NULL;
33616 }
33617
33618
33619 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33620 PyObject *resultobj = 0;
33621 wxWindow *arg1 = (wxWindow *) 0 ;
33622 wxValidator *arg2 = 0 ;
33623 void *argp1 = 0 ;
33624 int res1 = 0 ;
33625 void *argp2 = 0 ;
33626 int res2 = 0 ;
33627 PyObject * obj0 = 0 ;
33628 PyObject * obj1 = 0 ;
33629 char * kwnames[] = {
33630 (char *) "self",(char *) "validator", NULL
33631 };
33632
33633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33635 if (!SWIG_IsOK(res1)) {
33636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33637 }
33638 arg1 = reinterpret_cast< wxWindow * >(argp1);
33639 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33640 if (!SWIG_IsOK(res2)) {
33641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33642 }
33643 if (!argp2) {
33644 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33645 }
33646 arg2 = reinterpret_cast< wxValidator * >(argp2);
33647 {
33648 PyThreadState* __tstate = wxPyBeginAllowThreads();
33649 (arg1)->SetValidator((wxValidator const &)*arg2);
33650 wxPyEndAllowThreads(__tstate);
33651 if (PyErr_Occurred()) SWIG_fail;
33652 }
33653 resultobj = SWIG_Py_Void();
33654 return resultobj;
33655 fail:
33656 return NULL;
33657 }
33658
33659
33660 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33661 PyObject *resultobj = 0;
33662 wxWindow *arg1 = (wxWindow *) 0 ;
33663 wxValidator *result = 0 ;
33664 void *argp1 = 0 ;
33665 int res1 = 0 ;
33666 PyObject *swig_obj[1] ;
33667
33668 if (!args) SWIG_fail;
33669 swig_obj[0] = args;
33670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33671 if (!SWIG_IsOK(res1)) {
33672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33673 }
33674 arg1 = reinterpret_cast< wxWindow * >(argp1);
33675 {
33676 PyThreadState* __tstate = wxPyBeginAllowThreads();
33677 result = (wxValidator *)(arg1)->GetValidator();
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 {
33682 resultobj = wxPyMake_wxObject(result, (bool)0);
33683 }
33684 return resultobj;
33685 fail:
33686 return NULL;
33687 }
33688
33689
33690 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33691 PyObject *resultobj = 0;
33692 wxWindow *arg1 = (wxWindow *) 0 ;
33693 bool result;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 PyObject *swig_obj[1] ;
33697
33698 if (!args) SWIG_fail;
33699 swig_obj[0] = args;
33700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (bool)(arg1)->Validate();
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 {
33712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33713 }
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 bool result;
33724 void *argp1 = 0 ;
33725 int res1 = 0 ;
33726 PyObject *swig_obj[1] ;
33727
33728 if (!args) SWIG_fail;
33729 swig_obj[0] = args;
33730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 result = (bool)(arg1)->TransferDataToWindow();
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 {
33742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33743 }
33744 return resultobj;
33745 fail:
33746 return NULL;
33747 }
33748
33749
33750 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33751 PyObject *resultobj = 0;
33752 wxWindow *arg1 = (wxWindow *) 0 ;
33753 bool result;
33754 void *argp1 = 0 ;
33755 int res1 = 0 ;
33756 PyObject *swig_obj[1] ;
33757
33758 if (!args) SWIG_fail;
33759 swig_obj[0] = args;
33760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33761 if (!SWIG_IsOK(res1)) {
33762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33763 }
33764 arg1 = reinterpret_cast< wxWindow * >(argp1);
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 result = (bool)(arg1)->TransferDataFromWindow();
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 {
33772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33773 }
33774 return resultobj;
33775 fail:
33776 return NULL;
33777 }
33778
33779
33780 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33781 PyObject *resultobj = 0;
33782 wxWindow *arg1 = (wxWindow *) 0 ;
33783 void *argp1 = 0 ;
33784 int res1 = 0 ;
33785 PyObject *swig_obj[1] ;
33786
33787 if (!args) SWIG_fail;
33788 swig_obj[0] = args;
33789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33790 if (!SWIG_IsOK(res1)) {
33791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33792 }
33793 arg1 = reinterpret_cast< wxWindow * >(argp1);
33794 {
33795 PyThreadState* __tstate = wxPyBeginAllowThreads();
33796 (arg1)->InitDialog();
33797 wxPyEndAllowThreads(__tstate);
33798 if (PyErr_Occurred()) SWIG_fail;
33799 }
33800 resultobj = SWIG_Py_Void();
33801 return resultobj;
33802 fail:
33803 return NULL;
33804 }
33805
33806
33807 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33808 PyObject *resultobj = 0;
33809 wxWindow *arg1 = (wxWindow *) 0 ;
33810 wxAcceleratorTable *arg2 = 0 ;
33811 void *argp1 = 0 ;
33812 int res1 = 0 ;
33813 void *argp2 = 0 ;
33814 int res2 = 0 ;
33815 PyObject * obj0 = 0 ;
33816 PyObject * obj1 = 0 ;
33817 char * kwnames[] = {
33818 (char *) "self",(char *) "accel", NULL
33819 };
33820
33821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33823 if (!SWIG_IsOK(res1)) {
33824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33825 }
33826 arg1 = reinterpret_cast< wxWindow * >(argp1);
33827 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33828 if (!SWIG_IsOK(res2)) {
33829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33830 }
33831 if (!argp2) {
33832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33833 }
33834 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33835 {
33836 PyThreadState* __tstate = wxPyBeginAllowThreads();
33837 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 resultobj = SWIG_Py_Void();
33842 return resultobj;
33843 fail:
33844 return NULL;
33845 }
33846
33847
33848 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33849 PyObject *resultobj = 0;
33850 wxWindow *arg1 = (wxWindow *) 0 ;
33851 wxAcceleratorTable *result = 0 ;
33852 void *argp1 = 0 ;
33853 int res1 = 0 ;
33854 PyObject *swig_obj[1] ;
33855
33856 if (!args) SWIG_fail;
33857 swig_obj[0] = args;
33858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33859 if (!SWIG_IsOK(res1)) {
33860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33861 }
33862 arg1 = reinterpret_cast< wxWindow * >(argp1);
33863 {
33864 PyThreadState* __tstate = wxPyBeginAllowThreads();
33865 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33866 wxPyEndAllowThreads(__tstate);
33867 if (PyErr_Occurred()) SWIG_fail;
33868 }
33869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33870 return resultobj;
33871 fail:
33872 return NULL;
33873 }
33874
33875
33876 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33877 PyObject *resultobj = 0;
33878 wxWindow *arg1 = (wxWindow *) 0 ;
33879 int arg2 ;
33880 int arg3 ;
33881 int arg4 ;
33882 bool result;
33883 void *argp1 = 0 ;
33884 int res1 = 0 ;
33885 int val2 ;
33886 int ecode2 = 0 ;
33887 int val3 ;
33888 int ecode3 = 0 ;
33889 int val4 ;
33890 int ecode4 = 0 ;
33891 PyObject * obj0 = 0 ;
33892 PyObject * obj1 = 0 ;
33893 PyObject * obj2 = 0 ;
33894 PyObject * obj3 = 0 ;
33895 char * kwnames[] = {
33896 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33897 };
33898
33899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33901 if (!SWIG_IsOK(res1)) {
33902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33903 }
33904 arg1 = reinterpret_cast< wxWindow * >(argp1);
33905 ecode2 = SWIG_AsVal_int(obj1, &val2);
33906 if (!SWIG_IsOK(ecode2)) {
33907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33908 }
33909 arg2 = static_cast< int >(val2);
33910 ecode3 = SWIG_AsVal_int(obj2, &val3);
33911 if (!SWIG_IsOK(ecode3)) {
33912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33913 }
33914 arg3 = static_cast< int >(val3);
33915 ecode4 = SWIG_AsVal_int(obj3, &val4);
33916 if (!SWIG_IsOK(ecode4)) {
33917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33918 }
33919 arg4 = static_cast< int >(val4);
33920 {
33921 PyThreadState* __tstate = wxPyBeginAllowThreads();
33922 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33923 wxPyEndAllowThreads(__tstate);
33924 if (PyErr_Occurred()) SWIG_fail;
33925 }
33926 {
33927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33928 }
33929 return resultobj;
33930 fail:
33931 return NULL;
33932 }
33933
33934
33935 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33936 PyObject *resultobj = 0;
33937 wxWindow *arg1 = (wxWindow *) 0 ;
33938 int arg2 ;
33939 bool result;
33940 void *argp1 = 0 ;
33941 int res1 = 0 ;
33942 int val2 ;
33943 int ecode2 = 0 ;
33944 PyObject * obj0 = 0 ;
33945 PyObject * obj1 = 0 ;
33946 char * kwnames[] = {
33947 (char *) "self",(char *) "hotkeyId", NULL
33948 };
33949
33950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33952 if (!SWIG_IsOK(res1)) {
33953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33954 }
33955 arg1 = reinterpret_cast< wxWindow * >(argp1);
33956 ecode2 = SWIG_AsVal_int(obj1, &val2);
33957 if (!SWIG_IsOK(ecode2)) {
33958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33959 }
33960 arg2 = static_cast< int >(val2);
33961 {
33962 PyThreadState* __tstate = wxPyBeginAllowThreads();
33963 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33964 wxPyEndAllowThreads(__tstate);
33965 if (PyErr_Occurred()) SWIG_fail;
33966 }
33967 {
33968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33969 }
33970 return resultobj;
33971 fail:
33972 return NULL;
33973 }
33974
33975
33976 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33977 PyObject *resultobj = 0;
33978 wxWindow *arg1 = (wxWindow *) 0 ;
33979 wxPoint *arg2 = 0 ;
33980 wxPoint result;
33981 void *argp1 = 0 ;
33982 int res1 = 0 ;
33983 wxPoint temp2 ;
33984 PyObject * obj0 = 0 ;
33985 PyObject * obj1 = 0 ;
33986 char * kwnames[] = {
33987 (char *) "self",(char *) "pt", NULL
33988 };
33989
33990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33994 }
33995 arg1 = reinterpret_cast< wxWindow * >(argp1);
33996 {
33997 arg2 = &temp2;
33998 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33999 }
34000 {
34001 PyThreadState* __tstate = wxPyBeginAllowThreads();
34002 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34003 wxPyEndAllowThreads(__tstate);
34004 if (PyErr_Occurred()) SWIG_fail;
34005 }
34006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34007 return resultobj;
34008 fail:
34009 return NULL;
34010 }
34011
34012
34013 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34014 PyObject *resultobj = 0;
34015 wxWindow *arg1 = (wxWindow *) 0 ;
34016 wxSize *arg2 = 0 ;
34017 wxSize result;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 wxSize temp2 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 char * kwnames[] = {
34024 (char *) "self",(char *) "sz", NULL
34025 };
34026
34027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34031 }
34032 arg1 = reinterpret_cast< wxWindow * >(argp1);
34033 {
34034 arg2 = &temp2;
34035 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34036 }
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34051 PyObject *resultobj = 0;
34052 wxWindow *arg1 = (wxWindow *) 0 ;
34053 wxPoint *arg2 = 0 ;
34054 wxPoint result;
34055 void *argp1 = 0 ;
34056 int res1 = 0 ;
34057 wxPoint temp2 ;
34058 PyObject * obj0 = 0 ;
34059 PyObject * obj1 = 0 ;
34060 char * kwnames[] = {
34061 (char *) "self",(char *) "pt", NULL
34062 };
34063
34064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34066 if (!SWIG_IsOK(res1)) {
34067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34068 }
34069 arg1 = reinterpret_cast< wxWindow * >(argp1);
34070 {
34071 arg2 = &temp2;
34072 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34073 }
34074 {
34075 PyThreadState* __tstate = wxPyBeginAllowThreads();
34076 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34088 PyObject *resultobj = 0;
34089 wxWindow *arg1 = (wxWindow *) 0 ;
34090 wxSize *arg2 = 0 ;
34091 wxSize result;
34092 void *argp1 = 0 ;
34093 int res1 = 0 ;
34094 wxSize temp2 ;
34095 PyObject * obj0 = 0 ;
34096 PyObject * obj1 = 0 ;
34097 char * kwnames[] = {
34098 (char *) "self",(char *) "sz", NULL
34099 };
34100
34101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34103 if (!SWIG_IsOK(res1)) {
34104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34105 }
34106 arg1 = reinterpret_cast< wxWindow * >(argp1);
34107 {
34108 arg2 = &temp2;
34109 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34110 }
34111 {
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34114 wxPyEndAllowThreads(__tstate);
34115 if (PyErr_Occurred()) SWIG_fail;
34116 }
34117 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34118 return resultobj;
34119 fail:
34120 return NULL;
34121 }
34122
34123
34124 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34125 PyObject *resultobj = 0;
34126 wxWindow *arg1 = (wxWindow *) 0 ;
34127 wxPoint *arg2 = 0 ;
34128 wxPoint result;
34129 void *argp1 = 0 ;
34130 int res1 = 0 ;
34131 wxPoint temp2 ;
34132 PyObject * obj0 = 0 ;
34133 PyObject * obj1 = 0 ;
34134 char * kwnames[] = {
34135 (char *) "self",(char *) "pt", NULL
34136 };
34137
34138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34140 if (!SWIG_IsOK(res1)) {
34141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34142 }
34143 arg1 = reinterpret_cast< wxWindow * >(argp1);
34144 {
34145 arg2 = &temp2;
34146 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34147 }
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34155 return resultobj;
34156 fail:
34157 return NULL;
34158 }
34159
34160
34161 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34162 PyObject *resultobj = 0;
34163 wxWindow *arg1 = (wxWindow *) 0 ;
34164 wxSize *arg2 = 0 ;
34165 wxSize result;
34166 void *argp1 = 0 ;
34167 int res1 = 0 ;
34168 wxSize temp2 ;
34169 PyObject * obj0 = 0 ;
34170 PyObject * obj1 = 0 ;
34171 char * kwnames[] = {
34172 (char *) "self",(char *) "sz", NULL
34173 };
34174
34175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34177 if (!SWIG_IsOK(res1)) {
34178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34179 }
34180 arg1 = reinterpret_cast< wxWindow * >(argp1);
34181 {
34182 arg2 = &temp2;
34183 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34184 }
34185 {
34186 PyThreadState* __tstate = wxPyBeginAllowThreads();
34187 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34199 PyObject *resultobj = 0;
34200 wxWindow *arg1 = (wxWindow *) 0 ;
34201 int arg2 ;
34202 int arg3 ;
34203 void *argp1 = 0 ;
34204 int res1 = 0 ;
34205 int val2 ;
34206 int ecode2 = 0 ;
34207 int val3 ;
34208 int ecode3 = 0 ;
34209 PyObject * obj0 = 0 ;
34210 PyObject * obj1 = 0 ;
34211 PyObject * obj2 = 0 ;
34212 char * kwnames[] = {
34213 (char *) "self",(char *) "x",(char *) "y", NULL
34214 };
34215
34216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34220 }
34221 arg1 = reinterpret_cast< wxWindow * >(argp1);
34222 ecode2 = SWIG_AsVal_int(obj1, &val2);
34223 if (!SWIG_IsOK(ecode2)) {
34224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34225 }
34226 arg2 = static_cast< int >(val2);
34227 ecode3 = SWIG_AsVal_int(obj2, &val3);
34228 if (!SWIG_IsOK(ecode3)) {
34229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34230 }
34231 arg3 = static_cast< int >(val3);
34232 {
34233 PyThreadState* __tstate = wxPyBeginAllowThreads();
34234 (arg1)->WarpPointer(arg2,arg3);
34235 wxPyEndAllowThreads(__tstate);
34236 if (PyErr_Occurred()) SWIG_fail;
34237 }
34238 resultobj = SWIG_Py_Void();
34239 return resultobj;
34240 fail:
34241 return NULL;
34242 }
34243
34244
34245 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34246 PyObject *resultobj = 0;
34247 wxWindow *arg1 = (wxWindow *) 0 ;
34248 void *argp1 = 0 ;
34249 int res1 = 0 ;
34250 PyObject *swig_obj[1] ;
34251
34252 if (!args) SWIG_fail;
34253 swig_obj[0] = args;
34254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34255 if (!SWIG_IsOK(res1)) {
34256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34257 }
34258 arg1 = reinterpret_cast< wxWindow * >(argp1);
34259 {
34260 PyThreadState* __tstate = wxPyBeginAllowThreads();
34261 (arg1)->CaptureMouse();
34262 wxPyEndAllowThreads(__tstate);
34263 if (PyErr_Occurred()) SWIG_fail;
34264 }
34265 resultobj = SWIG_Py_Void();
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34273 PyObject *resultobj = 0;
34274 wxWindow *arg1 = (wxWindow *) 0 ;
34275 void *argp1 = 0 ;
34276 int res1 = 0 ;
34277 PyObject *swig_obj[1] ;
34278
34279 if (!args) SWIG_fail;
34280 swig_obj[0] = args;
34281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34282 if (!SWIG_IsOK(res1)) {
34283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34284 }
34285 arg1 = reinterpret_cast< wxWindow * >(argp1);
34286 {
34287 PyThreadState* __tstate = wxPyBeginAllowThreads();
34288 (arg1)->ReleaseMouse();
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 resultobj = SWIG_Py_Void();
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34300 PyObject *resultobj = 0;
34301 wxWindow *result = 0 ;
34302
34303 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34304 {
34305 if (!wxPyCheckForApp()) SWIG_fail;
34306 PyThreadState* __tstate = wxPyBeginAllowThreads();
34307 result = (wxWindow *)wxWindow::GetCapture();
34308 wxPyEndAllowThreads(__tstate);
34309 if (PyErr_Occurred()) SWIG_fail;
34310 }
34311 {
34312 resultobj = wxPyMake_wxObject(result, 0);
34313 }
34314 return resultobj;
34315 fail:
34316 return NULL;
34317 }
34318
34319
34320 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34321 PyObject *resultobj = 0;
34322 wxWindow *arg1 = (wxWindow *) 0 ;
34323 bool result;
34324 void *argp1 = 0 ;
34325 int res1 = 0 ;
34326 PyObject *swig_obj[1] ;
34327
34328 if (!args) SWIG_fail;
34329 swig_obj[0] = args;
34330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34331 if (!SWIG_IsOK(res1)) {
34332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34333 }
34334 arg1 = reinterpret_cast< wxWindow * >(argp1);
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (bool)((wxWindow const *)arg1)->HasCapture();
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 {
34342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34343 }
34344 return resultobj;
34345 fail:
34346 return NULL;
34347 }
34348
34349
34350 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34351 PyObject *resultobj = 0;
34352 wxWindow *arg1 = (wxWindow *) 0 ;
34353 bool arg2 = (bool) true ;
34354 wxRect *arg3 = (wxRect *) NULL ;
34355 void *argp1 = 0 ;
34356 int res1 = 0 ;
34357 bool val2 ;
34358 int ecode2 = 0 ;
34359 void *argp3 = 0 ;
34360 int res3 = 0 ;
34361 PyObject * obj0 = 0 ;
34362 PyObject * obj1 = 0 ;
34363 PyObject * obj2 = 0 ;
34364 char * kwnames[] = {
34365 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34366 };
34367
34368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34370 if (!SWIG_IsOK(res1)) {
34371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34372 }
34373 arg1 = reinterpret_cast< wxWindow * >(argp1);
34374 if (obj1) {
34375 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34376 if (!SWIG_IsOK(ecode2)) {
34377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34378 }
34379 arg2 = static_cast< bool >(val2);
34380 }
34381 if (obj2) {
34382 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34383 if (!SWIG_IsOK(res3)) {
34384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34385 }
34386 arg3 = reinterpret_cast< wxRect * >(argp3);
34387 }
34388 {
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34391 wxPyEndAllowThreads(__tstate);
34392 if (PyErr_Occurred()) SWIG_fail;
34393 }
34394 resultobj = SWIG_Py_Void();
34395 return resultobj;
34396 fail:
34397 return NULL;
34398 }
34399
34400
34401 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34402 PyObject *resultobj = 0;
34403 wxWindow *arg1 = (wxWindow *) 0 ;
34404 wxRect *arg2 = 0 ;
34405 bool arg3 = (bool) true ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 wxRect temp2 ;
34409 bool val3 ;
34410 int ecode3 = 0 ;
34411 PyObject * obj0 = 0 ;
34412 PyObject * obj1 = 0 ;
34413 PyObject * obj2 = 0 ;
34414 char * kwnames[] = {
34415 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34416 };
34417
34418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34420 if (!SWIG_IsOK(res1)) {
34421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34422 }
34423 arg1 = reinterpret_cast< wxWindow * >(argp1);
34424 {
34425 arg2 = &temp2;
34426 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34427 }
34428 if (obj2) {
34429 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34430 if (!SWIG_IsOK(ecode3)) {
34431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34432 }
34433 arg3 = static_cast< bool >(val3);
34434 }
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 resultobj = SWIG_Py_Void();
34442 return resultobj;
34443 fail:
34444 return NULL;
34445 }
34446
34447
34448 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34449 PyObject *resultobj = 0;
34450 wxWindow *arg1 = (wxWindow *) 0 ;
34451 void *argp1 = 0 ;
34452 int res1 = 0 ;
34453 PyObject *swig_obj[1] ;
34454
34455 if (!args) SWIG_fail;
34456 swig_obj[0] = args;
34457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34458 if (!SWIG_IsOK(res1)) {
34459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34460 }
34461 arg1 = reinterpret_cast< wxWindow * >(argp1);
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 (arg1)->Update();
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 resultobj = SWIG_Py_Void();
34469 return resultobj;
34470 fail:
34471 return NULL;
34472 }
34473
34474
34475 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34476 PyObject *resultobj = 0;
34477 wxWindow *arg1 = (wxWindow *) 0 ;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 PyObject *swig_obj[1] ;
34481
34482 if (!args) SWIG_fail;
34483 swig_obj[0] = args;
34484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34485 if (!SWIG_IsOK(res1)) {
34486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34487 }
34488 arg1 = reinterpret_cast< wxWindow * >(argp1);
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 (arg1)->ClearBackground();
34492 wxPyEndAllowThreads(__tstate);
34493 if (PyErr_Occurred()) SWIG_fail;
34494 }
34495 resultobj = SWIG_Py_Void();
34496 return resultobj;
34497 fail:
34498 return NULL;
34499 }
34500
34501
34502 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34503 PyObject *resultobj = 0;
34504 wxWindow *arg1 = (wxWindow *) 0 ;
34505 void *argp1 = 0 ;
34506 int res1 = 0 ;
34507 PyObject *swig_obj[1] ;
34508
34509 if (!args) SWIG_fail;
34510 swig_obj[0] = args;
34511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34512 if (!SWIG_IsOK(res1)) {
34513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34514 }
34515 arg1 = reinterpret_cast< wxWindow * >(argp1);
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 (arg1)->Freeze();
34519 wxPyEndAllowThreads(__tstate);
34520 if (PyErr_Occurred()) SWIG_fail;
34521 }
34522 resultobj = SWIG_Py_Void();
34523 return resultobj;
34524 fail:
34525 return NULL;
34526 }
34527
34528
34529 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34530 PyObject *resultobj = 0;
34531 wxWindow *arg1 = (wxWindow *) 0 ;
34532 void *argp1 = 0 ;
34533 int res1 = 0 ;
34534 PyObject *swig_obj[1] ;
34535
34536 if (!args) SWIG_fail;
34537 swig_obj[0] = args;
34538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34541 }
34542 arg1 = reinterpret_cast< wxWindow * >(argp1);
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 (arg1)->Thaw();
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 resultobj = SWIG_Py_Void();
34550 return resultobj;
34551 fail:
34552 return NULL;
34553 }
34554
34555
34556 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34557 PyObject *resultobj = 0;
34558 wxWindow *arg1 = (wxWindow *) 0 ;
34559 wxDC *arg2 = 0 ;
34560 void *argp1 = 0 ;
34561 int res1 = 0 ;
34562 void *argp2 = 0 ;
34563 int res2 = 0 ;
34564 PyObject * obj0 = 0 ;
34565 PyObject * obj1 = 0 ;
34566 char * kwnames[] = {
34567 (char *) "self",(char *) "dc", NULL
34568 };
34569
34570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34572 if (!SWIG_IsOK(res1)) {
34573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34574 }
34575 arg1 = reinterpret_cast< wxWindow * >(argp1);
34576 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34577 if (!SWIG_IsOK(res2)) {
34578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34579 }
34580 if (!argp2) {
34581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34582 }
34583 arg2 = reinterpret_cast< wxDC * >(argp2);
34584 {
34585 PyThreadState* __tstate = wxPyBeginAllowThreads();
34586 (arg1)->PrepareDC(*arg2);
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 resultobj = SWIG_Py_Void();
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34598 PyObject *resultobj = 0;
34599 wxWindow *arg1 = (wxWindow *) 0 ;
34600 wxRegion *result = 0 ;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 PyObject *swig_obj[1] ;
34604
34605 if (!args) SWIG_fail;
34606 swig_obj[0] = args;
34607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34610 }
34611 arg1 = reinterpret_cast< wxWindow * >(argp1);
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 {
34615 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34616 result = (wxRegion *) &_result_ref;
34617 }
34618 wxPyEndAllowThreads(__tstate);
34619 if (PyErr_Occurred()) SWIG_fail;
34620 }
34621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34629 PyObject *resultobj = 0;
34630 wxWindow *arg1 = (wxWindow *) 0 ;
34631 wxRect result;
34632 void *argp1 = 0 ;
34633 int res1 = 0 ;
34634 PyObject *swig_obj[1] ;
34635
34636 if (!args) SWIG_fail;
34637 swig_obj[0] = args;
34638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34639 if (!SWIG_IsOK(res1)) {
34640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34641 }
34642 arg1 = reinterpret_cast< wxWindow * >(argp1);
34643 {
34644 PyThreadState* __tstate = wxPyBeginAllowThreads();
34645 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34646 wxPyEndAllowThreads(__tstate);
34647 if (PyErr_Occurred()) SWIG_fail;
34648 }
34649 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34650 return resultobj;
34651 fail:
34652 return NULL;
34653 }
34654
34655
34656 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34657 PyObject *resultobj = 0;
34658 wxWindow *arg1 = (wxWindow *) 0 ;
34659 int arg2 ;
34660 int arg3 ;
34661 int arg4 = (int) 1 ;
34662 int arg5 = (int) 1 ;
34663 bool result;
34664 void *argp1 = 0 ;
34665 int res1 = 0 ;
34666 int val2 ;
34667 int ecode2 = 0 ;
34668 int val3 ;
34669 int ecode3 = 0 ;
34670 int val4 ;
34671 int ecode4 = 0 ;
34672 int val5 ;
34673 int ecode5 = 0 ;
34674 PyObject * obj0 = 0 ;
34675 PyObject * obj1 = 0 ;
34676 PyObject * obj2 = 0 ;
34677 PyObject * obj3 = 0 ;
34678 PyObject * obj4 = 0 ;
34679 char * kwnames[] = {
34680 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34681 };
34682
34683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34685 if (!SWIG_IsOK(res1)) {
34686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34687 }
34688 arg1 = reinterpret_cast< wxWindow * >(argp1);
34689 ecode2 = SWIG_AsVal_int(obj1, &val2);
34690 if (!SWIG_IsOK(ecode2)) {
34691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34692 }
34693 arg2 = static_cast< int >(val2);
34694 ecode3 = SWIG_AsVal_int(obj2, &val3);
34695 if (!SWIG_IsOK(ecode3)) {
34696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34697 }
34698 arg3 = static_cast< int >(val3);
34699 if (obj3) {
34700 ecode4 = SWIG_AsVal_int(obj3, &val4);
34701 if (!SWIG_IsOK(ecode4)) {
34702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34703 }
34704 arg4 = static_cast< int >(val4);
34705 }
34706 if (obj4) {
34707 ecode5 = SWIG_AsVal_int(obj4, &val5);
34708 if (!SWIG_IsOK(ecode5)) {
34709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34710 }
34711 arg5 = static_cast< int >(val5);
34712 }
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 {
34720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34721 }
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34729 PyObject *resultobj = 0;
34730 wxWindow *arg1 = (wxWindow *) 0 ;
34731 wxPoint *arg2 = 0 ;
34732 bool result;
34733 void *argp1 = 0 ;
34734 int res1 = 0 ;
34735 wxPoint temp2 ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 char * kwnames[] = {
34739 (char *) "self",(char *) "pt", NULL
34740 };
34741
34742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34744 if (!SWIG_IsOK(res1)) {
34745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34746 }
34747 arg1 = reinterpret_cast< wxWindow * >(argp1);
34748 {
34749 arg2 = &temp2;
34750 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34751 }
34752 {
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 {
34759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34760 }
34761 return resultobj;
34762 fail:
34763 return NULL;
34764 }
34765
34766
34767 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34768 PyObject *resultobj = 0;
34769 wxWindow *arg1 = (wxWindow *) 0 ;
34770 wxRect *arg2 = 0 ;
34771 bool result;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 wxRect temp2 ;
34775 PyObject * obj0 = 0 ;
34776 PyObject * obj1 = 0 ;
34777 char * kwnames[] = {
34778 (char *) "self",(char *) "rect", NULL
34779 };
34780
34781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34783 if (!SWIG_IsOK(res1)) {
34784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34785 }
34786 arg1 = reinterpret_cast< wxWindow * >(argp1);
34787 {
34788 arg2 = &temp2;
34789 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34790 }
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 {
34798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34799 }
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34807 PyObject *resultobj = 0;
34808 wxWindow *arg1 = (wxWindow *) 0 ;
34809 SwigValueWrapper<wxVisualAttributes > result;
34810 void *argp1 = 0 ;
34811 int res1 = 0 ;
34812 PyObject *swig_obj[1] ;
34813
34814 if (!args) SWIG_fail;
34815 swig_obj[0] = args;
34816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34817 if (!SWIG_IsOK(res1)) {
34818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34819 }
34820 arg1 = reinterpret_cast< wxWindow * >(argp1);
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34828 return resultobj;
34829 fail:
34830 return NULL;
34831 }
34832
34833
34834 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34835 PyObject *resultobj = 0;
34836 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34837 SwigValueWrapper<wxVisualAttributes > result;
34838 int val1 ;
34839 int ecode1 = 0 ;
34840 PyObject * obj0 = 0 ;
34841 char * kwnames[] = {
34842 (char *) "variant", NULL
34843 };
34844
34845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34846 if (obj0) {
34847 ecode1 = SWIG_AsVal_int(obj0, &val1);
34848 if (!SWIG_IsOK(ecode1)) {
34849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34850 }
34851 arg1 = static_cast< wxWindowVariant >(val1);
34852 }
34853 {
34854 if (!wxPyCheckForApp()) SWIG_fail;
34855 PyThreadState* __tstate = wxPyBeginAllowThreads();
34856 result = wxWindow::GetClassDefaultAttributes(arg1);
34857 wxPyEndAllowThreads(__tstate);
34858 if (PyErr_Occurred()) SWIG_fail;
34859 }
34860 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34861 return resultobj;
34862 fail:
34863 return NULL;
34864 }
34865
34866
34867 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34868 PyObject *resultobj = 0;
34869 wxWindow *arg1 = (wxWindow *) 0 ;
34870 wxColour *arg2 = 0 ;
34871 bool result;
34872 void *argp1 = 0 ;
34873 int res1 = 0 ;
34874 wxColour temp2 ;
34875 PyObject * obj0 = 0 ;
34876 PyObject * obj1 = 0 ;
34877 char * kwnames[] = {
34878 (char *) "self",(char *) "colour", NULL
34879 };
34880
34881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34883 if (!SWIG_IsOK(res1)) {
34884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34885 }
34886 arg1 = reinterpret_cast< wxWindow * >(argp1);
34887 {
34888 arg2 = &temp2;
34889 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34890 }
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 {
34898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34899 }
34900 return resultobj;
34901 fail:
34902 return NULL;
34903 }
34904
34905
34906 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34907 PyObject *resultobj = 0;
34908 wxWindow *arg1 = (wxWindow *) 0 ;
34909 wxColour *arg2 = 0 ;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 wxColour temp2 ;
34913 PyObject * obj0 = 0 ;
34914 PyObject * obj1 = 0 ;
34915 char * kwnames[] = {
34916 (char *) "self",(char *) "colour", NULL
34917 };
34918
34919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34921 if (!SWIG_IsOK(res1)) {
34922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34923 }
34924 arg1 = reinterpret_cast< wxWindow * >(argp1);
34925 {
34926 arg2 = &temp2;
34927 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34928 }
34929 {
34930 PyThreadState* __tstate = wxPyBeginAllowThreads();
34931 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34932 wxPyEndAllowThreads(__tstate);
34933 if (PyErr_Occurred()) SWIG_fail;
34934 }
34935 resultobj = SWIG_Py_Void();
34936 return resultobj;
34937 fail:
34938 return NULL;
34939 }
34940
34941
34942 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34943 PyObject *resultobj = 0;
34944 wxWindow *arg1 = (wxWindow *) 0 ;
34945 wxColour *arg2 = 0 ;
34946 bool result;
34947 void *argp1 = 0 ;
34948 int res1 = 0 ;
34949 wxColour temp2 ;
34950 PyObject * obj0 = 0 ;
34951 PyObject * obj1 = 0 ;
34952 char * kwnames[] = {
34953 (char *) "self",(char *) "colour", NULL
34954 };
34955
34956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 {
34963 arg2 = &temp2;
34964 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34965 }
34966 {
34967 PyThreadState* __tstate = wxPyBeginAllowThreads();
34968 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34969 wxPyEndAllowThreads(__tstate);
34970 if (PyErr_Occurred()) SWIG_fail;
34971 }
34972 {
34973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34974 }
34975 return resultobj;
34976 fail:
34977 return NULL;
34978 }
34979
34980
34981 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34982 PyObject *resultobj = 0;
34983 wxWindow *arg1 = (wxWindow *) 0 ;
34984 wxColour *arg2 = 0 ;
34985 void *argp1 = 0 ;
34986 int res1 = 0 ;
34987 wxColour temp2 ;
34988 PyObject * obj0 = 0 ;
34989 PyObject * obj1 = 0 ;
34990 char * kwnames[] = {
34991 (char *) "self",(char *) "colour", NULL
34992 };
34993
34994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34996 if (!SWIG_IsOK(res1)) {
34997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34998 }
34999 arg1 = reinterpret_cast< wxWindow * >(argp1);
35000 {
35001 arg2 = &temp2;
35002 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35003 }
35004 {
35005 PyThreadState* __tstate = wxPyBeginAllowThreads();
35006 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35007 wxPyEndAllowThreads(__tstate);
35008 if (PyErr_Occurred()) SWIG_fail;
35009 }
35010 resultobj = SWIG_Py_Void();
35011 return resultobj;
35012 fail:
35013 return NULL;
35014 }
35015
35016
35017 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35018 PyObject *resultobj = 0;
35019 wxWindow *arg1 = (wxWindow *) 0 ;
35020 wxColour result;
35021 void *argp1 = 0 ;
35022 int res1 = 0 ;
35023 PyObject *swig_obj[1] ;
35024
35025 if (!args) SWIG_fail;
35026 swig_obj[0] = args;
35027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35028 if (!SWIG_IsOK(res1)) {
35029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35030 }
35031 arg1 = reinterpret_cast< wxWindow * >(argp1);
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35035 wxPyEndAllowThreads(__tstate);
35036 if (PyErr_Occurred()) SWIG_fail;
35037 }
35038 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35039 return resultobj;
35040 fail:
35041 return NULL;
35042 }
35043
35044
35045 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35046 PyObject *resultobj = 0;
35047 wxWindow *arg1 = (wxWindow *) 0 ;
35048 wxColour result;
35049 void *argp1 = 0 ;
35050 int res1 = 0 ;
35051 PyObject *swig_obj[1] ;
35052
35053 if (!args) SWIG_fail;
35054 swig_obj[0] = args;
35055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35056 if (!SWIG_IsOK(res1)) {
35057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35058 }
35059 arg1 = reinterpret_cast< wxWindow * >(argp1);
35060 {
35061 PyThreadState* __tstate = wxPyBeginAllowThreads();
35062 result = ((wxWindow const *)arg1)->GetForegroundColour();
35063 wxPyEndAllowThreads(__tstate);
35064 if (PyErr_Occurred()) SWIG_fail;
35065 }
35066 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35074 PyObject *resultobj = 0;
35075 wxWindow *arg1 = (wxWindow *) 0 ;
35076 bool result;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 PyObject *swig_obj[1] ;
35080
35081 if (!args) SWIG_fail;
35082 swig_obj[0] = args;
35083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35086 }
35087 arg1 = reinterpret_cast< wxWindow * >(argp1);
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35091 wxPyEndAllowThreads(__tstate);
35092 if (PyErr_Occurred()) SWIG_fail;
35093 }
35094 {
35095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35096 }
35097 return resultobj;
35098 fail:
35099 return NULL;
35100 }
35101
35102
35103 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35104 PyObject *resultobj = 0;
35105 wxWindow *arg1 = (wxWindow *) 0 ;
35106 bool result;
35107 void *argp1 = 0 ;
35108 int res1 = 0 ;
35109 PyObject *swig_obj[1] ;
35110
35111 if (!args) SWIG_fail;
35112 swig_obj[0] = args;
35113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35116 }
35117 arg1 = reinterpret_cast< wxWindow * >(argp1);
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35121 wxPyEndAllowThreads(__tstate);
35122 if (PyErr_Occurred()) SWIG_fail;
35123 }
35124 {
35125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35126 }
35127 return resultobj;
35128 fail:
35129 return NULL;
35130 }
35131
35132
35133 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35134 PyObject *resultobj = 0;
35135 wxWindow *arg1 = (wxWindow *) 0 ;
35136 wxBackgroundStyle arg2 ;
35137 bool result;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 int val2 ;
35141 int ecode2 = 0 ;
35142 PyObject * obj0 = 0 ;
35143 PyObject * obj1 = 0 ;
35144 char * kwnames[] = {
35145 (char *) "self",(char *) "style", NULL
35146 };
35147
35148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35150 if (!SWIG_IsOK(res1)) {
35151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35152 }
35153 arg1 = reinterpret_cast< wxWindow * >(argp1);
35154 ecode2 = SWIG_AsVal_int(obj1, &val2);
35155 if (!SWIG_IsOK(ecode2)) {
35156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35157 }
35158 arg2 = static_cast< wxBackgroundStyle >(val2);
35159 {
35160 PyThreadState* __tstate = wxPyBeginAllowThreads();
35161 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35162 wxPyEndAllowThreads(__tstate);
35163 if (PyErr_Occurred()) SWIG_fail;
35164 }
35165 {
35166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35167 }
35168 return resultobj;
35169 fail:
35170 return NULL;
35171 }
35172
35173
35174 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35175 PyObject *resultobj = 0;
35176 wxWindow *arg1 = (wxWindow *) 0 ;
35177 wxBackgroundStyle result;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 PyObject *swig_obj[1] ;
35181
35182 if (!args) SWIG_fail;
35183 swig_obj[0] = args;
35184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35187 }
35188 arg1 = reinterpret_cast< wxWindow * >(argp1);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_From_int(static_cast< int >(result));
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 bool result;
35206 void *argp1 = 0 ;
35207 int res1 = 0 ;
35208 PyObject *swig_obj[1] ;
35209
35210 if (!args) SWIG_fail;
35211 swig_obj[0] = args;
35212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35213 if (!SWIG_IsOK(res1)) {
35214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35215 }
35216 arg1 = reinterpret_cast< wxWindow * >(argp1);
35217 {
35218 PyThreadState* __tstate = wxPyBeginAllowThreads();
35219 result = (bool)(arg1)->HasTransparentBackground();
35220 wxPyEndAllowThreads(__tstate);
35221 if (PyErr_Occurred()) SWIG_fail;
35222 }
35223 {
35224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35225 }
35226 return resultobj;
35227 fail:
35228 return NULL;
35229 }
35230
35231
35232 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35233 PyObject *resultobj = 0;
35234 wxWindow *arg1 = (wxWindow *) 0 ;
35235 wxCursor *arg2 = 0 ;
35236 bool result;
35237 void *argp1 = 0 ;
35238 int res1 = 0 ;
35239 void *argp2 = 0 ;
35240 int res2 = 0 ;
35241 PyObject * obj0 = 0 ;
35242 PyObject * obj1 = 0 ;
35243 char * kwnames[] = {
35244 (char *) "self",(char *) "cursor", NULL
35245 };
35246
35247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35249 if (!SWIG_IsOK(res1)) {
35250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35251 }
35252 arg1 = reinterpret_cast< wxWindow * >(argp1);
35253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35254 if (!SWIG_IsOK(res2)) {
35255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35256 }
35257 if (!argp2) {
35258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35259 }
35260 arg2 = reinterpret_cast< wxCursor * >(argp2);
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35264 wxPyEndAllowThreads(__tstate);
35265 if (PyErr_Occurred()) SWIG_fail;
35266 }
35267 {
35268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35269 }
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 wxCursor result;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 PyObject *swig_obj[1] ;
35283
35284 if (!args) SWIG_fail;
35285 swig_obj[0] = args;
35286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35287 if (!SWIG_IsOK(res1)) {
35288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35289 }
35290 arg1 = reinterpret_cast< wxWindow * >(argp1);
35291 {
35292 PyThreadState* __tstate = wxPyBeginAllowThreads();
35293 result = (arg1)->GetCursor();
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35298 return resultobj;
35299 fail:
35300 return NULL;
35301 }
35302
35303
35304 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35305 PyObject *resultobj = 0;
35306 wxWindow *arg1 = (wxWindow *) 0 ;
35307 wxFont *arg2 = 0 ;
35308 bool result;
35309 void *argp1 = 0 ;
35310 int res1 = 0 ;
35311 void *argp2 = 0 ;
35312 int res2 = 0 ;
35313 PyObject * obj0 = 0 ;
35314 PyObject * obj1 = 0 ;
35315 char * kwnames[] = {
35316 (char *) "self",(char *) "font", NULL
35317 };
35318
35319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35321 if (!SWIG_IsOK(res1)) {
35322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35323 }
35324 arg1 = reinterpret_cast< wxWindow * >(argp1);
35325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35326 if (!SWIG_IsOK(res2)) {
35327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35328 }
35329 if (!argp2) {
35330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35331 }
35332 arg2 = reinterpret_cast< wxFont * >(argp2);
35333 {
35334 PyThreadState* __tstate = wxPyBeginAllowThreads();
35335 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 {
35340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35341 }
35342 return resultobj;
35343 fail:
35344 return NULL;
35345 }
35346
35347
35348 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35349 PyObject *resultobj = 0;
35350 wxWindow *arg1 = (wxWindow *) 0 ;
35351 wxFont *arg2 = 0 ;
35352 void *argp1 = 0 ;
35353 int res1 = 0 ;
35354 void *argp2 = 0 ;
35355 int res2 = 0 ;
35356 PyObject * obj0 = 0 ;
35357 PyObject * obj1 = 0 ;
35358 char * kwnames[] = {
35359 (char *) "self",(char *) "font", NULL
35360 };
35361
35362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35364 if (!SWIG_IsOK(res1)) {
35365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35366 }
35367 arg1 = reinterpret_cast< wxWindow * >(argp1);
35368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35369 if (!SWIG_IsOK(res2)) {
35370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35371 }
35372 if (!argp2) {
35373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35374 }
35375 arg2 = reinterpret_cast< wxFont * >(argp2);
35376 {
35377 PyThreadState* __tstate = wxPyBeginAllowThreads();
35378 (arg1)->SetOwnFont((wxFont const &)*arg2);
35379 wxPyEndAllowThreads(__tstate);
35380 if (PyErr_Occurred()) SWIG_fail;
35381 }
35382 resultobj = SWIG_Py_Void();
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35390 PyObject *resultobj = 0;
35391 wxWindow *arg1 = (wxWindow *) 0 ;
35392 wxFont result;
35393 void *argp1 = 0 ;
35394 int res1 = 0 ;
35395 PyObject *swig_obj[1] ;
35396
35397 if (!args) SWIG_fail;
35398 swig_obj[0] = args;
35399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35400 if (!SWIG_IsOK(res1)) {
35401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35402 }
35403 arg1 = reinterpret_cast< wxWindow * >(argp1);
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (arg1)->GetFont();
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35418 PyObject *resultobj = 0;
35419 wxWindow *arg1 = (wxWindow *) 0 ;
35420 wxCaret *arg2 = (wxCaret *) 0 ;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 int res2 = 0 ;
35424 PyObject * obj0 = 0 ;
35425 PyObject * obj1 = 0 ;
35426 char * kwnames[] = {
35427 (char *) "self",(char *) "caret", NULL
35428 };
35429
35430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35432 if (!SWIG_IsOK(res1)) {
35433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35434 }
35435 arg1 = reinterpret_cast< wxWindow * >(argp1);
35436 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35437 if (!SWIG_IsOK(res2)) {
35438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35439 }
35440 {
35441 PyThreadState* __tstate = wxPyBeginAllowThreads();
35442 (arg1)->SetCaret(arg2);
35443 wxPyEndAllowThreads(__tstate);
35444 if (PyErr_Occurred()) SWIG_fail;
35445 }
35446 resultobj = SWIG_Py_Void();
35447 return resultobj;
35448 fail:
35449 return NULL;
35450 }
35451
35452
35453 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35454 PyObject *resultobj = 0;
35455 wxWindow *arg1 = (wxWindow *) 0 ;
35456 wxCaret *result = 0 ;
35457 void *argp1 = 0 ;
35458 int res1 = 0 ;
35459 PyObject *swig_obj[1] ;
35460
35461 if (!args) SWIG_fail;
35462 swig_obj[0] = args;
35463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35464 if (!SWIG_IsOK(res1)) {
35465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35466 }
35467 arg1 = reinterpret_cast< wxWindow * >(argp1);
35468 {
35469 PyThreadState* __tstate = wxPyBeginAllowThreads();
35470 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35475 return resultobj;
35476 fail:
35477 return NULL;
35478 }
35479
35480
35481 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35482 PyObject *resultobj = 0;
35483 wxWindow *arg1 = (wxWindow *) 0 ;
35484 int result;
35485 void *argp1 = 0 ;
35486 int res1 = 0 ;
35487 PyObject *swig_obj[1] ;
35488
35489 if (!args) SWIG_fail;
35490 swig_obj[0] = args;
35491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35492 if (!SWIG_IsOK(res1)) {
35493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35494 }
35495 arg1 = reinterpret_cast< wxWindow * >(argp1);
35496 {
35497 PyThreadState* __tstate = wxPyBeginAllowThreads();
35498 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35499 wxPyEndAllowThreads(__tstate);
35500 if (PyErr_Occurred()) SWIG_fail;
35501 }
35502 resultobj = SWIG_From_int(static_cast< int >(result));
35503 return resultobj;
35504 fail:
35505 return NULL;
35506 }
35507
35508
35509 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35510 PyObject *resultobj = 0;
35511 wxWindow *arg1 = (wxWindow *) 0 ;
35512 int result;
35513 void *argp1 = 0 ;
35514 int res1 = 0 ;
35515 PyObject *swig_obj[1] ;
35516
35517 if (!args) SWIG_fail;
35518 swig_obj[0] = args;
35519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35520 if (!SWIG_IsOK(res1)) {
35521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35522 }
35523 arg1 = reinterpret_cast< wxWindow * >(argp1);
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35527 wxPyEndAllowThreads(__tstate);
35528 if (PyErr_Occurred()) SWIG_fail;
35529 }
35530 resultobj = SWIG_From_int(static_cast< int >(result));
35531 return resultobj;
35532 fail:
35533 return NULL;
35534 }
35535
35536
35537 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35538 PyObject *resultobj = 0;
35539 wxWindow *arg1 = (wxWindow *) 0 ;
35540 wxString *arg2 = 0 ;
35541 int *arg3 = (int *) 0 ;
35542 int *arg4 = (int *) 0 ;
35543 void *argp1 = 0 ;
35544 int res1 = 0 ;
35545 bool temp2 = false ;
35546 int temp3 ;
35547 int res3 = SWIG_TMPOBJ ;
35548 int temp4 ;
35549 int res4 = SWIG_TMPOBJ ;
35550 PyObject * obj0 = 0 ;
35551 PyObject * obj1 = 0 ;
35552 char * kwnames[] = {
35553 (char *) "self",(char *) "string", NULL
35554 };
35555
35556 arg3 = &temp3;
35557 arg4 = &temp4;
35558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35560 if (!SWIG_IsOK(res1)) {
35561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35562 }
35563 arg1 = reinterpret_cast< wxWindow * >(argp1);
35564 {
35565 arg2 = wxString_in_helper(obj1);
35566 if (arg2 == NULL) SWIG_fail;
35567 temp2 = true;
35568 }
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35572 wxPyEndAllowThreads(__tstate);
35573 if (PyErr_Occurred()) SWIG_fail;
35574 }
35575 resultobj = SWIG_Py_Void();
35576 if (SWIG_IsTmpObj(res3)) {
35577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35578 } else {
35579 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35581 }
35582 if (SWIG_IsTmpObj(res4)) {
35583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35584 } else {
35585 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35587 }
35588 {
35589 if (temp2)
35590 delete arg2;
35591 }
35592 return resultobj;
35593 fail:
35594 {
35595 if (temp2)
35596 delete arg2;
35597 }
35598 return NULL;
35599 }
35600
35601
35602 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj = 0;
35604 wxWindow *arg1 = (wxWindow *) 0 ;
35605 wxString *arg2 = 0 ;
35606 int *arg3 = (int *) 0 ;
35607 int *arg4 = (int *) 0 ;
35608 int *arg5 = (int *) 0 ;
35609 int *arg6 = (int *) 0 ;
35610 wxFont *arg7 = (wxFont *) NULL ;
35611 void *argp1 = 0 ;
35612 int res1 = 0 ;
35613 bool temp2 = false ;
35614 int temp3 ;
35615 int res3 = SWIG_TMPOBJ ;
35616 int temp4 ;
35617 int res4 = SWIG_TMPOBJ ;
35618 int temp5 ;
35619 int res5 = SWIG_TMPOBJ ;
35620 int temp6 ;
35621 int res6 = SWIG_TMPOBJ ;
35622 void *argp7 = 0 ;
35623 int res7 = 0 ;
35624 PyObject * obj0 = 0 ;
35625 PyObject * obj1 = 0 ;
35626 PyObject * obj2 = 0 ;
35627 char * kwnames[] = {
35628 (char *) "self",(char *) "string",(char *) "font", NULL
35629 };
35630
35631 arg3 = &temp3;
35632 arg4 = &temp4;
35633 arg5 = &temp5;
35634 arg6 = &temp6;
35635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35637 if (!SWIG_IsOK(res1)) {
35638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35639 }
35640 arg1 = reinterpret_cast< wxWindow * >(argp1);
35641 {
35642 arg2 = wxString_in_helper(obj1);
35643 if (arg2 == NULL) SWIG_fail;
35644 temp2 = true;
35645 }
35646 if (obj2) {
35647 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35648 if (!SWIG_IsOK(res7)) {
35649 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35650 }
35651 arg7 = reinterpret_cast< wxFont * >(argp7);
35652 }
35653 {
35654 PyThreadState* __tstate = wxPyBeginAllowThreads();
35655 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35656 wxPyEndAllowThreads(__tstate);
35657 if (PyErr_Occurred()) SWIG_fail;
35658 }
35659 resultobj = SWIG_Py_Void();
35660 if (SWIG_IsTmpObj(res3)) {
35661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35662 } else {
35663 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35665 }
35666 if (SWIG_IsTmpObj(res4)) {
35667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35668 } else {
35669 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35671 }
35672 if (SWIG_IsTmpObj(res5)) {
35673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35674 } else {
35675 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35677 }
35678 if (SWIG_IsTmpObj(res6)) {
35679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35680 } else {
35681 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35683 }
35684 {
35685 if (temp2)
35686 delete arg2;
35687 }
35688 return resultobj;
35689 fail:
35690 {
35691 if (temp2)
35692 delete arg2;
35693 }
35694 return NULL;
35695 }
35696
35697
35698 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35699 PyObject *resultobj = 0;
35700 wxWindow *arg1 = (wxWindow *) 0 ;
35701 int *arg2 = (int *) 0 ;
35702 int *arg3 = (int *) 0 ;
35703 void *argp1 = 0 ;
35704 int res1 = 0 ;
35705 int temp2 ;
35706 int res2 = 0 ;
35707 int temp3 ;
35708 int res3 = 0 ;
35709 PyObject * obj0 = 0 ;
35710 PyObject * obj1 = 0 ;
35711 PyObject * obj2 = 0 ;
35712 char * kwnames[] = {
35713 (char *) "self",(char *) "x",(char *) "y", NULL
35714 };
35715
35716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35720 }
35721 arg1 = reinterpret_cast< wxWindow * >(argp1);
35722 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35723 int val;
35724 int ecode = SWIG_AsVal_int(obj1, &val);
35725 if (!SWIG_IsOK(ecode)) {
35726 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35727 }
35728 temp2 = static_cast< int >(val);
35729 arg2 = &temp2;
35730 res2 = SWIG_AddTmpMask(ecode);
35731 }
35732 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35733 int val;
35734 int ecode = SWIG_AsVal_int(obj2, &val);
35735 if (!SWIG_IsOK(ecode)) {
35736 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35737 }
35738 temp3 = static_cast< int >(val);
35739 arg3 = &temp3;
35740 res3 = SWIG_AddTmpMask(ecode);
35741 }
35742 {
35743 PyThreadState* __tstate = wxPyBeginAllowThreads();
35744 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35745 wxPyEndAllowThreads(__tstate);
35746 if (PyErr_Occurred()) SWIG_fail;
35747 }
35748 resultobj = SWIG_Py_Void();
35749 if (SWIG_IsTmpObj(res2)) {
35750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35751 } else {
35752 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35754 }
35755 if (SWIG_IsTmpObj(res3)) {
35756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35757 } else {
35758 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35760 }
35761 return resultobj;
35762 fail:
35763 return NULL;
35764 }
35765
35766
35767 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35768 PyObject *resultobj = 0;
35769 wxWindow *arg1 = (wxWindow *) 0 ;
35770 int *arg2 = (int *) 0 ;
35771 int *arg3 = (int *) 0 ;
35772 void *argp1 = 0 ;
35773 int res1 = 0 ;
35774 int temp2 ;
35775 int res2 = 0 ;
35776 int temp3 ;
35777 int res3 = 0 ;
35778 PyObject * obj0 = 0 ;
35779 PyObject * obj1 = 0 ;
35780 PyObject * obj2 = 0 ;
35781 char * kwnames[] = {
35782 (char *) "self",(char *) "x",(char *) "y", NULL
35783 };
35784
35785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35787 if (!SWIG_IsOK(res1)) {
35788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35789 }
35790 arg1 = reinterpret_cast< wxWindow * >(argp1);
35791 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35792 int val;
35793 int ecode = SWIG_AsVal_int(obj1, &val);
35794 if (!SWIG_IsOK(ecode)) {
35795 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35796 }
35797 temp2 = static_cast< int >(val);
35798 arg2 = &temp2;
35799 res2 = SWIG_AddTmpMask(ecode);
35800 }
35801 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35802 int val;
35803 int ecode = SWIG_AsVal_int(obj2, &val);
35804 if (!SWIG_IsOK(ecode)) {
35805 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35806 }
35807 temp3 = static_cast< int >(val);
35808 arg3 = &temp3;
35809 res3 = SWIG_AddTmpMask(ecode);
35810 }
35811 {
35812 PyThreadState* __tstate = wxPyBeginAllowThreads();
35813 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35814 wxPyEndAllowThreads(__tstate);
35815 if (PyErr_Occurred()) SWIG_fail;
35816 }
35817 resultobj = SWIG_Py_Void();
35818 if (SWIG_IsTmpObj(res2)) {
35819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35820 } else {
35821 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35823 }
35824 if (SWIG_IsTmpObj(res3)) {
35825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35826 } else {
35827 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35829 }
35830 return resultobj;
35831 fail:
35832 return NULL;
35833 }
35834
35835
35836 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35837 PyObject *resultobj = 0;
35838 wxWindow *arg1 = (wxWindow *) 0 ;
35839 wxPoint *arg2 = 0 ;
35840 wxPoint result;
35841 void *argp1 = 0 ;
35842 int res1 = 0 ;
35843 wxPoint temp2 ;
35844 PyObject * obj0 = 0 ;
35845 PyObject * obj1 = 0 ;
35846 char * kwnames[] = {
35847 (char *) "self",(char *) "pt", NULL
35848 };
35849
35850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35852 if (!SWIG_IsOK(res1)) {
35853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35854 }
35855 arg1 = reinterpret_cast< wxWindow * >(argp1);
35856 {
35857 arg2 = &temp2;
35858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35859 }
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj = 0;
35875 wxWindow *arg1 = (wxWindow *) 0 ;
35876 wxPoint *arg2 = 0 ;
35877 wxPoint result;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 wxPoint temp2 ;
35881 PyObject * obj0 = 0 ;
35882 PyObject * obj1 = 0 ;
35883 char * kwnames[] = {
35884 (char *) "self",(char *) "pt", NULL
35885 };
35886
35887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35889 if (!SWIG_IsOK(res1)) {
35890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35891 }
35892 arg1 = reinterpret_cast< wxWindow * >(argp1);
35893 {
35894 arg2 = &temp2;
35895 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35896 }
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35904 return resultobj;
35905 fail:
35906 return NULL;
35907 }
35908
35909
35910 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35911 PyObject *resultobj = 0;
35912 wxWindow *arg1 = (wxWindow *) 0 ;
35913 int arg2 ;
35914 int arg3 ;
35915 wxHitTest result;
35916 void *argp1 = 0 ;
35917 int res1 = 0 ;
35918 int val2 ;
35919 int ecode2 = 0 ;
35920 int val3 ;
35921 int ecode3 = 0 ;
35922 PyObject * obj0 = 0 ;
35923 PyObject * obj1 = 0 ;
35924 PyObject * obj2 = 0 ;
35925 char * kwnames[] = {
35926 (char *) "self",(char *) "x",(char *) "y", NULL
35927 };
35928
35929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35931 if (!SWIG_IsOK(res1)) {
35932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35933 }
35934 arg1 = reinterpret_cast< wxWindow * >(argp1);
35935 ecode2 = SWIG_AsVal_int(obj1, &val2);
35936 if (!SWIG_IsOK(ecode2)) {
35937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35938 }
35939 arg2 = static_cast< int >(val2);
35940 ecode3 = SWIG_AsVal_int(obj2, &val3);
35941 if (!SWIG_IsOK(ecode3)) {
35942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35943 }
35944 arg3 = static_cast< int >(val3);
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 resultobj = SWIG_From_int(static_cast< int >(result));
35952 return resultobj;
35953 fail:
35954 return NULL;
35955 }
35956
35957
35958 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35959 PyObject *resultobj = 0;
35960 wxWindow *arg1 = (wxWindow *) 0 ;
35961 wxPoint *arg2 = 0 ;
35962 wxHitTest result;
35963 void *argp1 = 0 ;
35964 int res1 = 0 ;
35965 wxPoint temp2 ;
35966 PyObject * obj0 = 0 ;
35967 PyObject * obj1 = 0 ;
35968 char * kwnames[] = {
35969 (char *) "self",(char *) "pt", NULL
35970 };
35971
35972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 {
35979 arg2 = &temp2;
35980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35981 }
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 resultobj = SWIG_From_int(static_cast< int >(result));
35989 return resultobj;
35990 fail:
35991 return NULL;
35992 }
35993
35994
35995 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35996 PyObject *resultobj = 0;
35997 wxWindow *arg1 = (wxWindow *) 0 ;
35998 long arg2 ;
35999 wxBorder result;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002 long val2 ;
36003 int ecode2 = 0 ;
36004
36005 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36009 }
36010 arg1 = reinterpret_cast< wxWindow * >(argp1);
36011 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36012 if (!SWIG_IsOK(ecode2)) {
36013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36014 }
36015 arg2 = static_cast< long >(val2);
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 resultobj = SWIG_From_int(static_cast< int >(result));
36023 return resultobj;
36024 fail:
36025 return NULL;
36026 }
36027
36028
36029 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36030 PyObject *resultobj = 0;
36031 wxWindow *arg1 = (wxWindow *) 0 ;
36032 wxBorder result;
36033 void *argp1 = 0 ;
36034 int res1 = 0 ;
36035
36036 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36038 if (!SWIG_IsOK(res1)) {
36039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36040 }
36041 arg1 = reinterpret_cast< wxWindow * >(argp1);
36042 {
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 resultobj = SWIG_From_int(static_cast< int >(result));
36049 return resultobj;
36050 fail:
36051 return NULL;
36052 }
36053
36054
36055 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36056 int argc;
36057 PyObject *argv[3];
36058
36059 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36060 --argc;
36061 if (argc == 1) {
36062 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36063 }
36064 if (argc == 2) {
36065 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36066 }
36067
36068 fail:
36069 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36070 return NULL;
36071 }
36072
36073
36074 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36075 PyObject *resultobj = 0;
36076 wxWindow *arg1 = (wxWindow *) 0 ;
36077 long arg2 = (long) wxUPDATE_UI_NONE ;
36078 void *argp1 = 0 ;
36079 int res1 = 0 ;
36080 long val2 ;
36081 int ecode2 = 0 ;
36082 PyObject * obj0 = 0 ;
36083 PyObject * obj1 = 0 ;
36084 char * kwnames[] = {
36085 (char *) "self",(char *) "flags", NULL
36086 };
36087
36088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36090 if (!SWIG_IsOK(res1)) {
36091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36092 }
36093 arg1 = reinterpret_cast< wxWindow * >(argp1);
36094 if (obj1) {
36095 ecode2 = SWIG_AsVal_long(obj1, &val2);
36096 if (!SWIG_IsOK(ecode2)) {
36097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36098 }
36099 arg2 = static_cast< long >(val2);
36100 }
36101 {
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 (arg1)->UpdateWindowUI(arg2);
36104 wxPyEndAllowThreads(__tstate);
36105 if (PyErr_Occurred()) SWIG_fail;
36106 }
36107 resultobj = SWIG_Py_Void();
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36115 PyObject *resultobj = 0;
36116 wxWindow *arg1 = (wxWindow *) 0 ;
36117 wxMenu *arg2 = (wxMenu *) 0 ;
36118 int arg3 = (int) -1 ;
36119 int arg4 = (int) -1 ;
36120 bool result;
36121 void *argp1 = 0 ;
36122 int res1 = 0 ;
36123 void *argp2 = 0 ;
36124 int res2 = 0 ;
36125 int val3 ;
36126 int ecode3 = 0 ;
36127 int val4 ;
36128 int ecode4 = 0 ;
36129 PyObject * obj0 = 0 ;
36130 PyObject * obj1 = 0 ;
36131 PyObject * obj2 = 0 ;
36132 PyObject * obj3 = 0 ;
36133 char * kwnames[] = {
36134 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36135 };
36136
36137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36139 if (!SWIG_IsOK(res1)) {
36140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36141 }
36142 arg1 = reinterpret_cast< wxWindow * >(argp1);
36143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36144 if (!SWIG_IsOK(res2)) {
36145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36146 }
36147 arg2 = reinterpret_cast< wxMenu * >(argp2);
36148 if (obj2) {
36149 ecode3 = SWIG_AsVal_int(obj2, &val3);
36150 if (!SWIG_IsOK(ecode3)) {
36151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36152 }
36153 arg3 = static_cast< int >(val3);
36154 }
36155 if (obj3) {
36156 ecode4 = SWIG_AsVal_int(obj3, &val4);
36157 if (!SWIG_IsOK(ecode4)) {
36158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36159 }
36160 arg4 = static_cast< int >(val4);
36161 }
36162 {
36163 PyThreadState* __tstate = wxPyBeginAllowThreads();
36164 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 {
36169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36170 }
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36178 PyObject *resultobj = 0;
36179 wxWindow *arg1 = (wxWindow *) 0 ;
36180 wxMenu *arg2 = (wxMenu *) 0 ;
36181 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36182 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36183 bool result;
36184 void *argp1 = 0 ;
36185 int res1 = 0 ;
36186 void *argp2 = 0 ;
36187 int res2 = 0 ;
36188 wxPoint temp3 ;
36189 PyObject * obj0 = 0 ;
36190 PyObject * obj1 = 0 ;
36191 PyObject * obj2 = 0 ;
36192 char * kwnames[] = {
36193 (char *) "self",(char *) "menu",(char *) "pos", NULL
36194 };
36195
36196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36198 if (!SWIG_IsOK(res1)) {
36199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36200 }
36201 arg1 = reinterpret_cast< wxWindow * >(argp1);
36202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36203 if (!SWIG_IsOK(res2)) {
36204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36205 }
36206 arg2 = reinterpret_cast< wxMenu * >(argp2);
36207 if (obj2) {
36208 {
36209 arg3 = &temp3;
36210 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36211 }
36212 }
36213 {
36214 PyThreadState* __tstate = wxPyBeginAllowThreads();
36215 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36216 wxPyEndAllowThreads(__tstate);
36217 if (PyErr_Occurred()) SWIG_fail;
36218 }
36219 {
36220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36221 }
36222 return resultobj;
36223 fail:
36224 return NULL;
36225 }
36226
36227
36228 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36229 PyObject *resultobj = 0;
36230 wxWindow *arg1 = (wxWindow *) 0 ;
36231 long result;
36232 void *argp1 = 0 ;
36233 int res1 = 0 ;
36234 PyObject *swig_obj[1] ;
36235
36236 if (!args) SWIG_fail;
36237 swig_obj[0] = args;
36238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36239 if (!SWIG_IsOK(res1)) {
36240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36241 }
36242 arg1 = reinterpret_cast< wxWindow * >(argp1);
36243 {
36244 PyThreadState* __tstate = wxPyBeginAllowThreads();
36245 result = (long)wxWindow_GetHandle(arg1);
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 resultobj = SWIG_From_long(static_cast< long >(result));
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36257 PyObject *resultobj = 0;
36258 wxWindow *arg1 = (wxWindow *) 0 ;
36259 long arg2 ;
36260 void *argp1 = 0 ;
36261 int res1 = 0 ;
36262 long val2 ;
36263 int ecode2 = 0 ;
36264 PyObject * obj0 = 0 ;
36265 PyObject * obj1 = 0 ;
36266 char * kwnames[] = {
36267 (char *) "self",(char *) "handle", NULL
36268 };
36269
36270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36272 if (!SWIG_IsOK(res1)) {
36273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36274 }
36275 arg1 = reinterpret_cast< wxWindow * >(argp1);
36276 ecode2 = SWIG_AsVal_long(obj1, &val2);
36277 if (!SWIG_IsOK(ecode2)) {
36278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36279 }
36280 arg2 = static_cast< long >(val2);
36281 {
36282 PyThreadState* __tstate = wxPyBeginAllowThreads();
36283 wxWindow_AssociateHandle(arg1,arg2);
36284 wxPyEndAllowThreads(__tstate);
36285 if (PyErr_Occurred()) SWIG_fail;
36286 }
36287 resultobj = SWIG_Py_Void();
36288 return resultobj;
36289 fail:
36290 return NULL;
36291 }
36292
36293
36294 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36295 PyObject *resultobj = 0;
36296 wxWindow *arg1 = (wxWindow *) 0 ;
36297 void *argp1 = 0 ;
36298 int res1 = 0 ;
36299 PyObject *swig_obj[1] ;
36300
36301 if (!args) SWIG_fail;
36302 swig_obj[0] = args;
36303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36304 if (!SWIG_IsOK(res1)) {
36305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36306 }
36307 arg1 = reinterpret_cast< wxWindow * >(argp1);
36308 {
36309 PyThreadState* __tstate = wxPyBeginAllowThreads();
36310 (arg1)->DissociateHandle();
36311 wxPyEndAllowThreads(__tstate);
36312 if (PyErr_Occurred()) SWIG_fail;
36313 }
36314 resultobj = SWIG_Py_Void();
36315 return resultobj;
36316 fail:
36317 return NULL;
36318 }
36319
36320
36321 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36322 PyObject *resultobj = 0;
36323 wxWindow *arg1 = (wxWindow *) 0 ;
36324 int arg2 ;
36325 bool result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 int val2 ;
36329 int ecode2 = 0 ;
36330 PyObject * obj0 = 0 ;
36331 PyObject * obj1 = 0 ;
36332 char * kwnames[] = {
36333 (char *) "self",(char *) "orient", NULL
36334 };
36335
36336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36338 if (!SWIG_IsOK(res1)) {
36339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36340 }
36341 arg1 = reinterpret_cast< wxWindow * >(argp1);
36342 ecode2 = SWIG_AsVal_int(obj1, &val2);
36343 if (!SWIG_IsOK(ecode2)) {
36344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36345 }
36346 arg2 = static_cast< int >(val2);
36347 {
36348 PyThreadState* __tstate = wxPyBeginAllowThreads();
36349 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36350 wxPyEndAllowThreads(__tstate);
36351 if (PyErr_Occurred()) SWIG_fail;
36352 }
36353 {
36354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36355 }
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36363 PyObject *resultobj = 0;
36364 wxWindow *arg1 = (wxWindow *) 0 ;
36365 int arg2 ;
36366 int arg3 ;
36367 int arg4 ;
36368 int arg5 ;
36369 bool arg6 = (bool) true ;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 int val2 ;
36373 int ecode2 = 0 ;
36374 int val3 ;
36375 int ecode3 = 0 ;
36376 int val4 ;
36377 int ecode4 = 0 ;
36378 int val5 ;
36379 int ecode5 = 0 ;
36380 bool val6 ;
36381 int ecode6 = 0 ;
36382 PyObject * obj0 = 0 ;
36383 PyObject * obj1 = 0 ;
36384 PyObject * obj2 = 0 ;
36385 PyObject * obj3 = 0 ;
36386 PyObject * obj4 = 0 ;
36387 PyObject * obj5 = 0 ;
36388 char * kwnames[] = {
36389 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36390 };
36391
36392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36394 if (!SWIG_IsOK(res1)) {
36395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36396 }
36397 arg1 = reinterpret_cast< wxWindow * >(argp1);
36398 ecode2 = SWIG_AsVal_int(obj1, &val2);
36399 if (!SWIG_IsOK(ecode2)) {
36400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36401 }
36402 arg2 = static_cast< int >(val2);
36403 ecode3 = SWIG_AsVal_int(obj2, &val3);
36404 if (!SWIG_IsOK(ecode3)) {
36405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36406 }
36407 arg3 = static_cast< int >(val3);
36408 ecode4 = SWIG_AsVal_int(obj3, &val4);
36409 if (!SWIG_IsOK(ecode4)) {
36410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36411 }
36412 arg4 = static_cast< int >(val4);
36413 ecode5 = SWIG_AsVal_int(obj4, &val5);
36414 if (!SWIG_IsOK(ecode5)) {
36415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36416 }
36417 arg5 = static_cast< int >(val5);
36418 if (obj5) {
36419 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36420 if (!SWIG_IsOK(ecode6)) {
36421 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36422 }
36423 arg6 = static_cast< bool >(val6);
36424 }
36425 {
36426 PyThreadState* __tstate = wxPyBeginAllowThreads();
36427 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36428 wxPyEndAllowThreads(__tstate);
36429 if (PyErr_Occurred()) SWIG_fail;
36430 }
36431 resultobj = SWIG_Py_Void();
36432 return resultobj;
36433 fail:
36434 return NULL;
36435 }
36436
36437
36438 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36439 PyObject *resultobj = 0;
36440 wxWindow *arg1 = (wxWindow *) 0 ;
36441 int arg2 ;
36442 int arg3 ;
36443 bool arg4 = (bool) true ;
36444 void *argp1 = 0 ;
36445 int res1 = 0 ;
36446 int val2 ;
36447 int ecode2 = 0 ;
36448 int val3 ;
36449 int ecode3 = 0 ;
36450 bool val4 ;
36451 int ecode4 = 0 ;
36452 PyObject * obj0 = 0 ;
36453 PyObject * obj1 = 0 ;
36454 PyObject * obj2 = 0 ;
36455 PyObject * obj3 = 0 ;
36456 char * kwnames[] = {
36457 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36458 };
36459
36460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36462 if (!SWIG_IsOK(res1)) {
36463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36464 }
36465 arg1 = reinterpret_cast< wxWindow * >(argp1);
36466 ecode2 = SWIG_AsVal_int(obj1, &val2);
36467 if (!SWIG_IsOK(ecode2)) {
36468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36469 }
36470 arg2 = static_cast< int >(val2);
36471 ecode3 = SWIG_AsVal_int(obj2, &val3);
36472 if (!SWIG_IsOK(ecode3)) {
36473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36474 }
36475 arg3 = static_cast< int >(val3);
36476 if (obj3) {
36477 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36478 if (!SWIG_IsOK(ecode4)) {
36479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36480 }
36481 arg4 = static_cast< bool >(val4);
36482 }
36483 {
36484 PyThreadState* __tstate = wxPyBeginAllowThreads();
36485 (arg1)->SetScrollPos(arg2,arg3,arg4);
36486 wxPyEndAllowThreads(__tstate);
36487 if (PyErr_Occurred()) SWIG_fail;
36488 }
36489 resultobj = SWIG_Py_Void();
36490 return resultobj;
36491 fail:
36492 return NULL;
36493 }
36494
36495
36496 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36497 PyObject *resultobj = 0;
36498 wxWindow *arg1 = (wxWindow *) 0 ;
36499 int arg2 ;
36500 int result;
36501 void *argp1 = 0 ;
36502 int res1 = 0 ;
36503 int val2 ;
36504 int ecode2 = 0 ;
36505 PyObject * obj0 = 0 ;
36506 PyObject * obj1 = 0 ;
36507 char * kwnames[] = {
36508 (char *) "self",(char *) "orientation", NULL
36509 };
36510
36511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36513 if (!SWIG_IsOK(res1)) {
36514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36515 }
36516 arg1 = reinterpret_cast< wxWindow * >(argp1);
36517 ecode2 = SWIG_AsVal_int(obj1, &val2);
36518 if (!SWIG_IsOK(ecode2)) {
36519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36520 }
36521 arg2 = static_cast< int >(val2);
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 resultobj = SWIG_From_int(static_cast< int >(result));
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj = 0;
36537 wxWindow *arg1 = (wxWindow *) 0 ;
36538 int arg2 ;
36539 int result;
36540 void *argp1 = 0 ;
36541 int res1 = 0 ;
36542 int val2 ;
36543 int ecode2 = 0 ;
36544 PyObject * obj0 = 0 ;
36545 PyObject * obj1 = 0 ;
36546 char * kwnames[] = {
36547 (char *) "self",(char *) "orientation", NULL
36548 };
36549
36550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36552 if (!SWIG_IsOK(res1)) {
36553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36554 }
36555 arg1 = reinterpret_cast< wxWindow * >(argp1);
36556 ecode2 = SWIG_AsVal_int(obj1, &val2);
36557 if (!SWIG_IsOK(ecode2)) {
36558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36559 }
36560 arg2 = static_cast< int >(val2);
36561 {
36562 PyThreadState* __tstate = wxPyBeginAllowThreads();
36563 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36564 wxPyEndAllowThreads(__tstate);
36565 if (PyErr_Occurred()) SWIG_fail;
36566 }
36567 resultobj = SWIG_From_int(static_cast< int >(result));
36568 return resultobj;
36569 fail:
36570 return NULL;
36571 }
36572
36573
36574 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36575 PyObject *resultobj = 0;
36576 wxWindow *arg1 = (wxWindow *) 0 ;
36577 int arg2 ;
36578 int result;
36579 void *argp1 = 0 ;
36580 int res1 = 0 ;
36581 int val2 ;
36582 int ecode2 = 0 ;
36583 PyObject * obj0 = 0 ;
36584 PyObject * obj1 = 0 ;
36585 char * kwnames[] = {
36586 (char *) "self",(char *) "orientation", NULL
36587 };
36588
36589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 ecode2 = SWIG_AsVal_int(obj1, &val2);
36596 if (!SWIG_IsOK(ecode2)) {
36597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36598 }
36599 arg2 = static_cast< int >(val2);
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 resultobj = SWIG_From_int(static_cast< int >(result));
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36614 PyObject *resultobj = 0;
36615 wxWindow *arg1 = (wxWindow *) 0 ;
36616 int arg2 ;
36617 int arg3 ;
36618 wxRect *arg4 = (wxRect *) NULL ;
36619 void *argp1 = 0 ;
36620 int res1 = 0 ;
36621 int val2 ;
36622 int ecode2 = 0 ;
36623 int val3 ;
36624 int ecode3 = 0 ;
36625 void *argp4 = 0 ;
36626 int res4 = 0 ;
36627 PyObject * obj0 = 0 ;
36628 PyObject * obj1 = 0 ;
36629 PyObject * obj2 = 0 ;
36630 PyObject * obj3 = 0 ;
36631 char * kwnames[] = {
36632 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36633 };
36634
36635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36637 if (!SWIG_IsOK(res1)) {
36638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36639 }
36640 arg1 = reinterpret_cast< wxWindow * >(argp1);
36641 ecode2 = SWIG_AsVal_int(obj1, &val2);
36642 if (!SWIG_IsOK(ecode2)) {
36643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36644 }
36645 arg2 = static_cast< int >(val2);
36646 ecode3 = SWIG_AsVal_int(obj2, &val3);
36647 if (!SWIG_IsOK(ecode3)) {
36648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36649 }
36650 arg3 = static_cast< int >(val3);
36651 if (obj3) {
36652 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36653 if (!SWIG_IsOK(res4)) {
36654 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36655 }
36656 arg4 = reinterpret_cast< wxRect * >(argp4);
36657 }
36658 {
36659 PyThreadState* __tstate = wxPyBeginAllowThreads();
36660 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36661 wxPyEndAllowThreads(__tstate);
36662 if (PyErr_Occurred()) SWIG_fail;
36663 }
36664 resultobj = SWIG_Py_Void();
36665 return resultobj;
36666 fail:
36667 return NULL;
36668 }
36669
36670
36671 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36672 PyObject *resultobj = 0;
36673 wxWindow *arg1 = (wxWindow *) 0 ;
36674 int arg2 ;
36675 bool result;
36676 void *argp1 = 0 ;
36677 int res1 = 0 ;
36678 int val2 ;
36679 int ecode2 = 0 ;
36680 PyObject * obj0 = 0 ;
36681 PyObject * obj1 = 0 ;
36682 char * kwnames[] = {
36683 (char *) "self",(char *) "lines", NULL
36684 };
36685
36686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36688 if (!SWIG_IsOK(res1)) {
36689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36690 }
36691 arg1 = reinterpret_cast< wxWindow * >(argp1);
36692 ecode2 = SWIG_AsVal_int(obj1, &val2);
36693 if (!SWIG_IsOK(ecode2)) {
36694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36695 }
36696 arg2 = static_cast< int >(val2);
36697 {
36698 PyThreadState* __tstate = wxPyBeginAllowThreads();
36699 result = (bool)(arg1)->ScrollLines(arg2);
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 {
36704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36705 }
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36713 PyObject *resultobj = 0;
36714 wxWindow *arg1 = (wxWindow *) 0 ;
36715 int arg2 ;
36716 bool result;
36717 void *argp1 = 0 ;
36718 int res1 = 0 ;
36719 int val2 ;
36720 int ecode2 = 0 ;
36721 PyObject * obj0 = 0 ;
36722 PyObject * obj1 = 0 ;
36723 char * kwnames[] = {
36724 (char *) "self",(char *) "pages", NULL
36725 };
36726
36727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36729 if (!SWIG_IsOK(res1)) {
36730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36731 }
36732 arg1 = reinterpret_cast< wxWindow * >(argp1);
36733 ecode2 = SWIG_AsVal_int(obj1, &val2);
36734 if (!SWIG_IsOK(ecode2)) {
36735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36736 }
36737 arg2 = static_cast< int >(val2);
36738 {
36739 PyThreadState* __tstate = wxPyBeginAllowThreads();
36740 result = (bool)(arg1)->ScrollPages(arg2);
36741 wxPyEndAllowThreads(__tstate);
36742 if (PyErr_Occurred()) SWIG_fail;
36743 }
36744 {
36745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36754 PyObject *resultobj = 0;
36755 wxWindow *arg1 = (wxWindow *) 0 ;
36756 bool result;
36757 void *argp1 = 0 ;
36758 int res1 = 0 ;
36759 PyObject *swig_obj[1] ;
36760
36761 if (!args) SWIG_fail;
36762 swig_obj[0] = args;
36763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36764 if (!SWIG_IsOK(res1)) {
36765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36766 }
36767 arg1 = reinterpret_cast< wxWindow * >(argp1);
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 result = (bool)(arg1)->LineUp();
36771 wxPyEndAllowThreads(__tstate);
36772 if (PyErr_Occurred()) SWIG_fail;
36773 }
36774 {
36775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36776 }
36777 return resultobj;
36778 fail:
36779 return NULL;
36780 }
36781
36782
36783 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36784 PyObject *resultobj = 0;
36785 wxWindow *arg1 = (wxWindow *) 0 ;
36786 bool result;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 PyObject *swig_obj[1] ;
36790
36791 if (!args) SWIG_fail;
36792 swig_obj[0] = args;
36793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 result = (bool)(arg1)->LineDown();
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 {
36805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36806 }
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36814 PyObject *resultobj = 0;
36815 wxWindow *arg1 = (wxWindow *) 0 ;
36816 bool result;
36817 void *argp1 = 0 ;
36818 int res1 = 0 ;
36819 PyObject *swig_obj[1] ;
36820
36821 if (!args) SWIG_fail;
36822 swig_obj[0] = args;
36823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36824 if (!SWIG_IsOK(res1)) {
36825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36826 }
36827 arg1 = reinterpret_cast< wxWindow * >(argp1);
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 result = (bool)(arg1)->PageUp();
36831 wxPyEndAllowThreads(__tstate);
36832 if (PyErr_Occurred()) SWIG_fail;
36833 }
36834 {
36835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36836 }
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36844 PyObject *resultobj = 0;
36845 wxWindow *arg1 = (wxWindow *) 0 ;
36846 bool result;
36847 void *argp1 = 0 ;
36848 int res1 = 0 ;
36849 PyObject *swig_obj[1] ;
36850
36851 if (!args) SWIG_fail;
36852 swig_obj[0] = args;
36853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36854 if (!SWIG_IsOK(res1)) {
36855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36856 }
36857 arg1 = reinterpret_cast< wxWindow * >(argp1);
36858 {
36859 PyThreadState* __tstate = wxPyBeginAllowThreads();
36860 result = (bool)(arg1)->PageDown();
36861 wxPyEndAllowThreads(__tstate);
36862 if (PyErr_Occurred()) SWIG_fail;
36863 }
36864 {
36865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36866 }
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj = 0;
36875 wxWindow *arg1 = (wxWindow *) 0 ;
36876 wxString *arg2 = 0 ;
36877 void *argp1 = 0 ;
36878 int res1 = 0 ;
36879 bool temp2 = false ;
36880 PyObject * obj0 = 0 ;
36881 PyObject * obj1 = 0 ;
36882 char * kwnames[] = {
36883 (char *) "self",(char *) "text", NULL
36884 };
36885
36886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36888 if (!SWIG_IsOK(res1)) {
36889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36890 }
36891 arg1 = reinterpret_cast< wxWindow * >(argp1);
36892 {
36893 arg2 = wxString_in_helper(obj1);
36894 if (arg2 == NULL) SWIG_fail;
36895 temp2 = true;
36896 }
36897 {
36898 PyThreadState* __tstate = wxPyBeginAllowThreads();
36899 (arg1)->SetHelpText((wxString const &)*arg2);
36900 wxPyEndAllowThreads(__tstate);
36901 if (PyErr_Occurred()) SWIG_fail;
36902 }
36903 resultobj = SWIG_Py_Void();
36904 {
36905 if (temp2)
36906 delete arg2;
36907 }
36908 return resultobj;
36909 fail:
36910 {
36911 if (temp2)
36912 delete arg2;
36913 }
36914 return NULL;
36915 }
36916
36917
36918 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36919 PyObject *resultobj = 0;
36920 wxWindow *arg1 = (wxWindow *) 0 ;
36921 wxString *arg2 = 0 ;
36922 void *argp1 = 0 ;
36923 int res1 = 0 ;
36924 bool temp2 = false ;
36925 PyObject * obj0 = 0 ;
36926 PyObject * obj1 = 0 ;
36927 char * kwnames[] = {
36928 (char *) "self",(char *) "text", NULL
36929 };
36930
36931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36933 if (!SWIG_IsOK(res1)) {
36934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36935 }
36936 arg1 = reinterpret_cast< wxWindow * >(argp1);
36937 {
36938 arg2 = wxString_in_helper(obj1);
36939 if (arg2 == NULL) SWIG_fail;
36940 temp2 = true;
36941 }
36942 {
36943 PyThreadState* __tstate = wxPyBeginAllowThreads();
36944 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36945 wxPyEndAllowThreads(__tstate);
36946 if (PyErr_Occurred()) SWIG_fail;
36947 }
36948 resultobj = SWIG_Py_Void();
36949 {
36950 if (temp2)
36951 delete arg2;
36952 }
36953 return resultobj;
36954 fail:
36955 {
36956 if (temp2)
36957 delete arg2;
36958 }
36959 return NULL;
36960 }
36961
36962
36963 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36964 PyObject *resultobj = 0;
36965 wxWindow *arg1 = (wxWindow *) 0 ;
36966 wxPoint *arg2 = 0 ;
36967 wxHelpEvent::Origin arg3 ;
36968 wxString result;
36969 void *argp1 = 0 ;
36970 int res1 = 0 ;
36971 wxPoint temp2 ;
36972 void *argp3 ;
36973 int res3 = 0 ;
36974 PyObject * obj0 = 0 ;
36975 PyObject * obj1 = 0 ;
36976 PyObject * obj2 = 0 ;
36977 char * kwnames[] = {
36978 (char *) "self",(char *) "pt",(char *) "origin", NULL
36979 };
36980
36981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36983 if (!SWIG_IsOK(res1)) {
36984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36985 }
36986 arg1 = reinterpret_cast< wxWindow * >(argp1);
36987 {
36988 arg2 = &temp2;
36989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36990 }
36991 {
36992 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36993 if (!SWIG_IsOK(res3)) {
36994 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36995 }
36996 if (!argp3) {
36997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36998 } else {
36999 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37000 arg3 = *temp;
37001 if (SWIG_IsNewObj(res3)) delete temp;
37002 }
37003 }
37004 {
37005 PyThreadState* __tstate = wxPyBeginAllowThreads();
37006 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 {
37011 #if wxUSE_UNICODE
37012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37013 #else
37014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37015 #endif
37016 }
37017 return resultobj;
37018 fail:
37019 return NULL;
37020 }
37021
37022
37023 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37024 PyObject *resultobj = 0;
37025 wxWindow *arg1 = (wxWindow *) 0 ;
37026 wxString result;
37027 void *argp1 = 0 ;
37028 int res1 = 0 ;
37029 PyObject *swig_obj[1] ;
37030
37031 if (!args) SWIG_fail;
37032 swig_obj[0] = args;
37033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37034 if (!SWIG_IsOK(res1)) {
37035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37036 }
37037 arg1 = reinterpret_cast< wxWindow * >(argp1);
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 result = ((wxWindow const *)arg1)->GetHelpText();
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 {
37045 #if wxUSE_UNICODE
37046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37047 #else
37048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37049 #endif
37050 }
37051 return resultobj;
37052 fail:
37053 return NULL;
37054 }
37055
37056
37057 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37058 PyObject *resultobj = 0;
37059 wxWindow *arg1 = (wxWindow *) 0 ;
37060 wxString *arg2 = 0 ;
37061 void *argp1 = 0 ;
37062 int res1 = 0 ;
37063 bool temp2 = false ;
37064 PyObject * obj0 = 0 ;
37065 PyObject * obj1 = 0 ;
37066 char * kwnames[] = {
37067 (char *) "self",(char *) "tip", NULL
37068 };
37069
37070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37072 if (!SWIG_IsOK(res1)) {
37073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37074 }
37075 arg1 = reinterpret_cast< wxWindow * >(argp1);
37076 {
37077 arg2 = wxString_in_helper(obj1);
37078 if (arg2 == NULL) SWIG_fail;
37079 temp2 = true;
37080 }
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 (arg1)->SetToolTip((wxString const &)*arg2);
37084 wxPyEndAllowThreads(__tstate);
37085 if (PyErr_Occurred()) SWIG_fail;
37086 }
37087 resultobj = SWIG_Py_Void();
37088 {
37089 if (temp2)
37090 delete arg2;
37091 }
37092 return resultobj;
37093 fail:
37094 {
37095 if (temp2)
37096 delete arg2;
37097 }
37098 return NULL;
37099 }
37100
37101
37102 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37103 PyObject *resultobj = 0;
37104 wxWindow *arg1 = (wxWindow *) 0 ;
37105 wxToolTip *arg2 = (wxToolTip *) 0 ;
37106 void *argp1 = 0 ;
37107 int res1 = 0 ;
37108 int res2 = 0 ;
37109 PyObject * obj0 = 0 ;
37110 PyObject * obj1 = 0 ;
37111 char * kwnames[] = {
37112 (char *) "self",(char *) "tip", NULL
37113 };
37114
37115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37117 if (!SWIG_IsOK(res1)) {
37118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37119 }
37120 arg1 = reinterpret_cast< wxWindow * >(argp1);
37121 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37122 if (!SWIG_IsOK(res2)) {
37123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37124 }
37125 {
37126 PyThreadState* __tstate = wxPyBeginAllowThreads();
37127 (arg1)->SetToolTip(arg2);
37128 wxPyEndAllowThreads(__tstate);
37129 if (PyErr_Occurred()) SWIG_fail;
37130 }
37131 resultobj = SWIG_Py_Void();
37132 return resultobj;
37133 fail:
37134 return NULL;
37135 }
37136
37137
37138 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37139 PyObject *resultobj = 0;
37140 wxWindow *arg1 = (wxWindow *) 0 ;
37141 wxToolTip *result = 0 ;
37142 void *argp1 = 0 ;
37143 int res1 = 0 ;
37144 PyObject *swig_obj[1] ;
37145
37146 if (!args) SWIG_fail;
37147 swig_obj[0] = args;
37148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 resultobj = wxPyMake_wxObject(result, (bool)0);
37161 }
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37172 void *argp1 = 0 ;
37173 int res1 = 0 ;
37174 int res2 = 0 ;
37175 PyObject * obj0 = 0 ;
37176 PyObject * obj1 = 0 ;
37177 char * kwnames[] = {
37178 (char *) "self",(char *) "dropTarget", NULL
37179 };
37180
37181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37188 if (!SWIG_IsOK(res2)) {
37189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37190 }
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 (arg1)->SetDropTarget(arg2);
37194 wxPyEndAllowThreads(__tstate);
37195 if (PyErr_Occurred()) SWIG_fail;
37196 }
37197 resultobj = SWIG_Py_Void();
37198 return resultobj;
37199 fail:
37200 return NULL;
37201 }
37202
37203
37204 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37205 PyObject *resultobj = 0;
37206 wxWindow *arg1 = (wxWindow *) 0 ;
37207 wxPyDropTarget *result = 0 ;
37208 void *argp1 = 0 ;
37209 int res1 = 0 ;
37210 PyObject *swig_obj[1] ;
37211
37212 if (!args) SWIG_fail;
37213 swig_obj[0] = args;
37214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37215 if (!SWIG_IsOK(res1)) {
37216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37217 }
37218 arg1 = reinterpret_cast< wxWindow * >(argp1);
37219 {
37220 PyThreadState* __tstate = wxPyBeginAllowThreads();
37221 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37222 wxPyEndAllowThreads(__tstate);
37223 if (PyErr_Occurred()) SWIG_fail;
37224 }
37225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37226 return resultobj;
37227 fail:
37228 return NULL;
37229 }
37230
37231
37232 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37233 PyObject *resultobj = 0;
37234 wxWindow *arg1 = (wxWindow *) 0 ;
37235 bool arg2 ;
37236 void *argp1 = 0 ;
37237 int res1 = 0 ;
37238 bool val2 ;
37239 int ecode2 = 0 ;
37240 PyObject * obj0 = 0 ;
37241 PyObject * obj1 = 0 ;
37242 char * kwnames[] = {
37243 (char *) "self",(char *) "accept", NULL
37244 };
37245
37246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37248 if (!SWIG_IsOK(res1)) {
37249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37250 }
37251 arg1 = reinterpret_cast< wxWindow * >(argp1);
37252 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37253 if (!SWIG_IsOK(ecode2)) {
37254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37255 }
37256 arg2 = static_cast< bool >(val2);
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 wxWindow_DragAcceptFiles(arg1,arg2);
37260 wxPyEndAllowThreads(__tstate);
37261 if (PyErr_Occurred()) SWIG_fail;
37262 }
37263 resultobj = SWIG_Py_Void();
37264 return resultobj;
37265 fail:
37266 return NULL;
37267 }
37268
37269
37270 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37271 PyObject *resultobj = 0;
37272 wxWindow *arg1 = (wxWindow *) 0 ;
37273 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37274 void *argp1 = 0 ;
37275 int res1 = 0 ;
37276 int res2 = 0 ;
37277 PyObject * obj0 = 0 ;
37278 PyObject * obj1 = 0 ;
37279 char * kwnames[] = {
37280 (char *) "self",(char *) "constraints", NULL
37281 };
37282
37283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37287 }
37288 arg1 = reinterpret_cast< wxWindow * >(argp1);
37289 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37290 if (!SWIG_IsOK(res2)) {
37291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37292 }
37293 {
37294 PyThreadState* __tstate = wxPyBeginAllowThreads();
37295 (arg1)->SetConstraints(arg2);
37296 wxPyEndAllowThreads(__tstate);
37297 if (PyErr_Occurred()) SWIG_fail;
37298 }
37299 resultobj = SWIG_Py_Void();
37300 return resultobj;
37301 fail:
37302 return NULL;
37303 }
37304
37305
37306 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37307 PyObject *resultobj = 0;
37308 wxWindow *arg1 = (wxWindow *) 0 ;
37309 wxLayoutConstraints *result = 0 ;
37310 void *argp1 = 0 ;
37311 int res1 = 0 ;
37312 PyObject *swig_obj[1] ;
37313
37314 if (!args) SWIG_fail;
37315 swig_obj[0] = args;
37316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37317 if (!SWIG_IsOK(res1)) {
37318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37319 }
37320 arg1 = reinterpret_cast< wxWindow * >(argp1);
37321 {
37322 PyThreadState* __tstate = wxPyBeginAllowThreads();
37323 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37324 wxPyEndAllowThreads(__tstate);
37325 if (PyErr_Occurred()) SWIG_fail;
37326 }
37327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37328 return resultobj;
37329 fail:
37330 return NULL;
37331 }
37332
37333
37334 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37335 PyObject *resultobj = 0;
37336 wxWindow *arg1 = (wxWindow *) 0 ;
37337 bool arg2 ;
37338 void *argp1 = 0 ;
37339 int res1 = 0 ;
37340 bool val2 ;
37341 int ecode2 = 0 ;
37342 PyObject * obj0 = 0 ;
37343 PyObject * obj1 = 0 ;
37344 char * kwnames[] = {
37345 (char *) "self",(char *) "autoLayout", NULL
37346 };
37347
37348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37350 if (!SWIG_IsOK(res1)) {
37351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37352 }
37353 arg1 = reinterpret_cast< wxWindow * >(argp1);
37354 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37355 if (!SWIG_IsOK(ecode2)) {
37356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37357 }
37358 arg2 = static_cast< bool >(val2);
37359 {
37360 PyThreadState* __tstate = wxPyBeginAllowThreads();
37361 (arg1)->SetAutoLayout(arg2);
37362 wxPyEndAllowThreads(__tstate);
37363 if (PyErr_Occurred()) SWIG_fail;
37364 }
37365 resultobj = SWIG_Py_Void();
37366 return resultobj;
37367 fail:
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 bool result;
37376 void *argp1 = 0 ;
37377 int res1 = 0 ;
37378 PyObject *swig_obj[1] ;
37379
37380 if (!args) SWIG_fail;
37381 swig_obj[0] = args;
37382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37383 if (!SWIG_IsOK(res1)) {
37384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37385 }
37386 arg1 = reinterpret_cast< wxWindow * >(argp1);
37387 {
37388 PyThreadState* __tstate = wxPyBeginAllowThreads();
37389 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 {
37394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37395 }
37396 return resultobj;
37397 fail:
37398 return NULL;
37399 }
37400
37401
37402 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37403 PyObject *resultobj = 0;
37404 wxWindow *arg1 = (wxWindow *) 0 ;
37405 bool result;
37406 void *argp1 = 0 ;
37407 int res1 = 0 ;
37408 PyObject *swig_obj[1] ;
37409
37410 if (!args) SWIG_fail;
37411 swig_obj[0] = args;
37412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37413 if (!SWIG_IsOK(res1)) {
37414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37415 }
37416 arg1 = reinterpret_cast< wxWindow * >(argp1);
37417 {
37418 PyThreadState* __tstate = wxPyBeginAllowThreads();
37419 result = (bool)(arg1)->Layout();
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37425 }
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37433 PyObject *resultobj = 0;
37434 wxWindow *arg1 = (wxWindow *) 0 ;
37435 wxSizer *arg2 = (wxSizer *) 0 ;
37436 bool arg3 = (bool) true ;
37437 void *argp1 = 0 ;
37438 int res1 = 0 ;
37439 int res2 = 0 ;
37440 bool val3 ;
37441 int ecode3 = 0 ;
37442 PyObject * obj0 = 0 ;
37443 PyObject * obj1 = 0 ;
37444 PyObject * obj2 = 0 ;
37445 char * kwnames[] = {
37446 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37447 };
37448
37449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37456 if (!SWIG_IsOK(res2)) {
37457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37458 }
37459 if (obj2) {
37460 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37461 if (!SWIG_IsOK(ecode3)) {
37462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37463 }
37464 arg3 = static_cast< bool >(val3);
37465 }
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 (arg1)->SetSizer(arg2,arg3);
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 resultobj = SWIG_Py_Void();
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37480 PyObject *resultobj = 0;
37481 wxWindow *arg1 = (wxWindow *) 0 ;
37482 wxSizer *arg2 = (wxSizer *) 0 ;
37483 bool arg3 = (bool) true ;
37484 void *argp1 = 0 ;
37485 int res1 = 0 ;
37486 int res2 = 0 ;
37487 bool val3 ;
37488 int ecode3 = 0 ;
37489 PyObject * obj0 = 0 ;
37490 PyObject * obj1 = 0 ;
37491 PyObject * obj2 = 0 ;
37492 char * kwnames[] = {
37493 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37494 };
37495
37496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37498 if (!SWIG_IsOK(res1)) {
37499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37500 }
37501 arg1 = reinterpret_cast< wxWindow * >(argp1);
37502 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37503 if (!SWIG_IsOK(res2)) {
37504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37505 }
37506 if (obj2) {
37507 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37508 if (!SWIG_IsOK(ecode3)) {
37509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37510 }
37511 arg3 = static_cast< bool >(val3);
37512 }
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->SetSizerAndFit(arg2,arg3);
37516 wxPyEndAllowThreads(__tstate);
37517 if (PyErr_Occurred()) SWIG_fail;
37518 }
37519 resultobj = SWIG_Py_Void();
37520 return resultobj;
37521 fail:
37522 return NULL;
37523 }
37524
37525
37526 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37527 PyObject *resultobj = 0;
37528 wxWindow *arg1 = (wxWindow *) 0 ;
37529 wxSizer *result = 0 ;
37530 void *argp1 = 0 ;
37531 int res1 = 0 ;
37532 PyObject *swig_obj[1] ;
37533
37534 if (!args) SWIG_fail;
37535 swig_obj[0] = args;
37536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37537 if (!SWIG_IsOK(res1)) {
37538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37539 }
37540 arg1 = reinterpret_cast< wxWindow * >(argp1);
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 {
37548 resultobj = wxPyMake_wxObject(result, (bool)0);
37549 }
37550 return resultobj;
37551 fail:
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37557 PyObject *resultobj = 0;
37558 wxWindow *arg1 = (wxWindow *) 0 ;
37559 wxSizer *arg2 = (wxSizer *) 0 ;
37560 void *argp1 = 0 ;
37561 int res1 = 0 ;
37562 void *argp2 = 0 ;
37563 int res2 = 0 ;
37564 PyObject * obj0 = 0 ;
37565 PyObject * obj1 = 0 ;
37566 char * kwnames[] = {
37567 (char *) "self",(char *) "sizer", NULL
37568 };
37569
37570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37574 }
37575 arg1 = reinterpret_cast< wxWindow * >(argp1);
37576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37577 if (!SWIG_IsOK(res2)) {
37578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37579 }
37580 arg2 = reinterpret_cast< wxSizer * >(argp2);
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 (arg1)->SetContainingSizer(arg2);
37584 wxPyEndAllowThreads(__tstate);
37585 if (PyErr_Occurred()) SWIG_fail;
37586 }
37587 resultobj = SWIG_Py_Void();
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37595 PyObject *resultobj = 0;
37596 wxWindow *arg1 = (wxWindow *) 0 ;
37597 wxSizer *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_wxWindow, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37607 }
37608 arg1 = reinterpret_cast< wxWindow * >(argp1);
37609 {
37610 PyThreadState* __tstate = wxPyBeginAllowThreads();
37611 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37612 wxPyEndAllowThreads(__tstate);
37613 if (PyErr_Occurred()) SWIG_fail;
37614 }
37615 {
37616 resultobj = wxPyMake_wxObject(result, (bool)0);
37617 }
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37625 PyObject *resultobj = 0;
37626 wxWindow *arg1 = (wxWindow *) 0 ;
37627 void *argp1 = 0 ;
37628 int res1 = 0 ;
37629 PyObject *swig_obj[1] ;
37630
37631 if (!args) SWIG_fail;
37632 swig_obj[0] = args;
37633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37634 if (!SWIG_IsOK(res1)) {
37635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37636 }
37637 arg1 = reinterpret_cast< wxWindow * >(argp1);
37638 {
37639 PyThreadState* __tstate = wxPyBeginAllowThreads();
37640 (arg1)->InheritAttributes();
37641 wxPyEndAllowThreads(__tstate);
37642 if (PyErr_Occurred()) SWIG_fail;
37643 }
37644 resultobj = SWIG_Py_Void();
37645 return resultobj;
37646 fail:
37647 return NULL;
37648 }
37649
37650
37651 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37652 PyObject *resultobj = 0;
37653 wxWindow *arg1 = (wxWindow *) 0 ;
37654 bool result;
37655 void *argp1 = 0 ;
37656 int res1 = 0 ;
37657 PyObject *swig_obj[1] ;
37658
37659 if (!args) SWIG_fail;
37660 swig_obj[0] = args;
37661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37662 if (!SWIG_IsOK(res1)) {
37663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37664 }
37665 arg1 = reinterpret_cast< wxWindow * >(argp1);
37666 {
37667 PyThreadState* __tstate = wxPyBeginAllowThreads();
37668 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37669 wxPyEndAllowThreads(__tstate);
37670 if (PyErr_Occurred()) SWIG_fail;
37671 }
37672 {
37673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37674 }
37675 return resultobj;
37676 fail:
37677 return NULL;
37678 }
37679
37680
37681 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37682 PyObject *obj;
37683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37684 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37685 return SWIG_Py_Void();
37686 }
37687
37688 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37689 return SWIG_Python_InitShadowInstance(args);
37690 }
37691
37692 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37693 PyObject *resultobj = 0;
37694 long arg1 ;
37695 wxWindow *arg2 = (wxWindow *) NULL ;
37696 wxWindow *result = 0 ;
37697 long val1 ;
37698 int ecode1 = 0 ;
37699 void *argp2 = 0 ;
37700 int res2 = 0 ;
37701 PyObject * obj0 = 0 ;
37702 PyObject * obj1 = 0 ;
37703 char * kwnames[] = {
37704 (char *) "id",(char *) "parent", NULL
37705 };
37706
37707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37708 ecode1 = SWIG_AsVal_long(obj0, &val1);
37709 if (!SWIG_IsOK(ecode1)) {
37710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37711 }
37712 arg1 = static_cast< long >(val1);
37713 if (obj1) {
37714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37715 if (!SWIG_IsOK(res2)) {
37716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37717 }
37718 arg2 = reinterpret_cast< wxWindow * >(argp2);
37719 }
37720 {
37721 if (!wxPyCheckForApp()) SWIG_fail;
37722 PyThreadState* __tstate = wxPyBeginAllowThreads();
37723 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37724 wxPyEndAllowThreads(__tstate);
37725 if (PyErr_Occurred()) SWIG_fail;
37726 }
37727 {
37728 resultobj = wxPyMake_wxObject(result, 0);
37729 }
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37737 PyObject *resultobj = 0;
37738 wxString *arg1 = 0 ;
37739 wxWindow *arg2 = (wxWindow *) NULL ;
37740 wxWindow *result = 0 ;
37741 bool temp1 = false ;
37742 void *argp2 = 0 ;
37743 int res2 = 0 ;
37744 PyObject * obj0 = 0 ;
37745 PyObject * obj1 = 0 ;
37746 char * kwnames[] = {
37747 (char *) "name",(char *) "parent", NULL
37748 };
37749
37750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37751 {
37752 arg1 = wxString_in_helper(obj0);
37753 if (arg1 == NULL) SWIG_fail;
37754 temp1 = true;
37755 }
37756 if (obj1) {
37757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37758 if (!SWIG_IsOK(res2)) {
37759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37760 }
37761 arg2 = reinterpret_cast< wxWindow * >(argp2);
37762 }
37763 {
37764 if (!wxPyCheckForApp()) SWIG_fail;
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37767 wxPyEndAllowThreads(__tstate);
37768 if (PyErr_Occurred()) SWIG_fail;
37769 }
37770 {
37771 resultobj = wxPyMake_wxObject(result, 0);
37772 }
37773 {
37774 if (temp1)
37775 delete arg1;
37776 }
37777 return resultobj;
37778 fail:
37779 {
37780 if (temp1)
37781 delete arg1;
37782 }
37783 return NULL;
37784 }
37785
37786
37787 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37788 PyObject *resultobj = 0;
37789 wxString *arg1 = 0 ;
37790 wxWindow *arg2 = (wxWindow *) NULL ;
37791 wxWindow *result = 0 ;
37792 bool temp1 = false ;
37793 void *argp2 = 0 ;
37794 int res2 = 0 ;
37795 PyObject * obj0 = 0 ;
37796 PyObject * obj1 = 0 ;
37797 char * kwnames[] = {
37798 (char *) "label",(char *) "parent", NULL
37799 };
37800
37801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37802 {
37803 arg1 = wxString_in_helper(obj0);
37804 if (arg1 == NULL) SWIG_fail;
37805 temp1 = true;
37806 }
37807 if (obj1) {
37808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37809 if (!SWIG_IsOK(res2)) {
37810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37811 }
37812 arg2 = reinterpret_cast< wxWindow * >(argp2);
37813 }
37814 {
37815 if (!wxPyCheckForApp()) SWIG_fail;
37816 PyThreadState* __tstate = wxPyBeginAllowThreads();
37817 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37818 wxPyEndAllowThreads(__tstate);
37819 if (PyErr_Occurred()) SWIG_fail;
37820 }
37821 {
37822 resultobj = wxPyMake_wxObject(result, 0);
37823 }
37824 {
37825 if (temp1)
37826 delete arg1;
37827 }
37828 return resultobj;
37829 fail:
37830 {
37831 if (temp1)
37832 delete arg1;
37833 }
37834 return NULL;
37835 }
37836
37837
37838 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37839 PyObject *resultobj = 0;
37840 wxWindow *arg1 = (wxWindow *) 0 ;
37841 unsigned long arg2 ;
37842 wxWindow *result = 0 ;
37843 void *argp1 = 0 ;
37844 int res1 = 0 ;
37845 unsigned long val2 ;
37846 int ecode2 = 0 ;
37847 PyObject * obj0 = 0 ;
37848 PyObject * obj1 = 0 ;
37849 char * kwnames[] = {
37850 (char *) "parent",(char *) "_hWnd", NULL
37851 };
37852
37853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37855 if (!SWIG_IsOK(res1)) {
37856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37857 }
37858 arg1 = reinterpret_cast< wxWindow * >(argp1);
37859 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37860 if (!SWIG_IsOK(ecode2)) {
37861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37862 }
37863 arg2 = static_cast< unsigned long >(val2);
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 {
37871 resultobj = wxPyMake_wxObject(result, 0);
37872 }
37873 return resultobj;
37874 fail:
37875 return NULL;
37876 }
37877
37878
37879 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37880 PyObject *resultobj = 0;
37881 PyObject *result = 0 ;
37882
37883 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37884 {
37885 PyThreadState* __tstate = wxPyBeginAllowThreads();
37886 result = (PyObject *)GetTopLevelWindows();
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 resultobj = result;
37891 return resultobj;
37892 fail:
37893 return NULL;
37894 }
37895
37896
37897 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37898 PyObject *resultobj = 0;
37899 wxValidator *result = 0 ;
37900
37901 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37902 {
37903 PyThreadState* __tstate = wxPyBeginAllowThreads();
37904 result = (wxValidator *)new wxValidator();
37905 wxPyEndAllowThreads(__tstate);
37906 if (PyErr_Occurred()) SWIG_fail;
37907 }
37908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37909 return resultobj;
37910 fail:
37911 return NULL;
37912 }
37913
37914
37915 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37916 PyObject *resultobj = 0;
37917 wxValidator *arg1 = (wxValidator *) 0 ;
37918 wxValidator *result = 0 ;
37919 void *argp1 = 0 ;
37920 int res1 = 0 ;
37921 PyObject *swig_obj[1] ;
37922
37923 if (!args) SWIG_fail;
37924 swig_obj[0] = args;
37925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37926 if (!SWIG_IsOK(res1)) {
37927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37928 }
37929 arg1 = reinterpret_cast< wxValidator * >(argp1);
37930 {
37931 PyThreadState* __tstate = wxPyBeginAllowThreads();
37932 result = (wxValidator *)(arg1)->Clone();
37933 wxPyEndAllowThreads(__tstate);
37934 if (PyErr_Occurred()) SWIG_fail;
37935 }
37936 {
37937 resultobj = wxPyMake_wxObject(result, 0);
37938 }
37939 return resultobj;
37940 fail:
37941 return NULL;
37942 }
37943
37944
37945 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37946 PyObject *resultobj = 0;
37947 wxValidator *arg1 = (wxValidator *) 0 ;
37948 wxWindow *arg2 = (wxWindow *) 0 ;
37949 bool result;
37950 void *argp1 = 0 ;
37951 int res1 = 0 ;
37952 void *argp2 = 0 ;
37953 int res2 = 0 ;
37954 PyObject * obj0 = 0 ;
37955 PyObject * obj1 = 0 ;
37956 char * kwnames[] = {
37957 (char *) "self",(char *) "parent", NULL
37958 };
37959
37960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37962 if (!SWIG_IsOK(res1)) {
37963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37964 }
37965 arg1 = reinterpret_cast< wxValidator * >(argp1);
37966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37967 if (!SWIG_IsOK(res2)) {
37968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37969 }
37970 arg2 = reinterpret_cast< wxWindow * >(argp2);
37971 {
37972 PyThreadState* __tstate = wxPyBeginAllowThreads();
37973 result = (bool)(arg1)->Validate(arg2);
37974 wxPyEndAllowThreads(__tstate);
37975 if (PyErr_Occurred()) SWIG_fail;
37976 }
37977 {
37978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37979 }
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37987 PyObject *resultobj = 0;
37988 wxValidator *arg1 = (wxValidator *) 0 ;
37989 bool result;
37990 void *argp1 = 0 ;
37991 int res1 = 0 ;
37992 PyObject *swig_obj[1] ;
37993
37994 if (!args) SWIG_fail;
37995 swig_obj[0] = args;
37996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37997 if (!SWIG_IsOK(res1)) {
37998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37999 }
38000 arg1 = reinterpret_cast< wxValidator * >(argp1);
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (bool)(arg1)->TransferToWindow();
38004 wxPyEndAllowThreads(__tstate);
38005 if (PyErr_Occurred()) SWIG_fail;
38006 }
38007 {
38008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38009 }
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38017 PyObject *resultobj = 0;
38018 wxValidator *arg1 = (wxValidator *) 0 ;
38019 bool result;
38020 void *argp1 = 0 ;
38021 int res1 = 0 ;
38022 PyObject *swig_obj[1] ;
38023
38024 if (!args) SWIG_fail;
38025 swig_obj[0] = args;
38026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38027 if (!SWIG_IsOK(res1)) {
38028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38029 }
38030 arg1 = reinterpret_cast< wxValidator * >(argp1);
38031 {
38032 PyThreadState* __tstate = wxPyBeginAllowThreads();
38033 result = (bool)(arg1)->TransferFromWindow();
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 {
38038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38039 }
38040 return resultobj;
38041 fail:
38042 return NULL;
38043 }
38044
38045
38046 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38047 PyObject *resultobj = 0;
38048 wxValidator *arg1 = (wxValidator *) 0 ;
38049 wxWindow *result = 0 ;
38050 void *argp1 = 0 ;
38051 int res1 = 0 ;
38052 PyObject *swig_obj[1] ;
38053
38054 if (!args) SWIG_fail;
38055 swig_obj[0] = args;
38056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38057 if (!SWIG_IsOK(res1)) {
38058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38059 }
38060 arg1 = reinterpret_cast< wxValidator * >(argp1);
38061 {
38062 PyThreadState* __tstate = wxPyBeginAllowThreads();
38063 result = (wxWindow *)(arg1)->GetWindow();
38064 wxPyEndAllowThreads(__tstate);
38065 if (PyErr_Occurred()) SWIG_fail;
38066 }
38067 {
38068 resultobj = wxPyMake_wxObject(result, 0);
38069 }
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj = 0;
38078 wxValidator *arg1 = (wxValidator *) 0 ;
38079 wxWindow *arg2 = (wxWindow *) 0 ;
38080 void *argp1 = 0 ;
38081 int res1 = 0 ;
38082 void *argp2 = 0 ;
38083 int res2 = 0 ;
38084 PyObject * obj0 = 0 ;
38085 PyObject * obj1 = 0 ;
38086 char * kwnames[] = {
38087 (char *) "self",(char *) "window", NULL
38088 };
38089
38090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38094 }
38095 arg1 = reinterpret_cast< wxValidator * >(argp1);
38096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38097 if (!SWIG_IsOK(res2)) {
38098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38099 }
38100 arg2 = reinterpret_cast< wxWindow * >(argp2);
38101 {
38102 PyThreadState* __tstate = wxPyBeginAllowThreads();
38103 (arg1)->SetWindow(arg2);
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 resultobj = SWIG_Py_Void();
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38115 PyObject *resultobj = 0;
38116 bool result;
38117
38118 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38119 {
38120 PyThreadState* __tstate = wxPyBeginAllowThreads();
38121 result = (bool)wxValidator::IsSilent();
38122 wxPyEndAllowThreads(__tstate);
38123 if (PyErr_Occurred()) SWIG_fail;
38124 }
38125 {
38126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38127 }
38128 return resultobj;
38129 fail:
38130 return NULL;
38131 }
38132
38133
38134 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38135 PyObject *resultobj = 0;
38136 int arg1 = (int) true ;
38137 int val1 ;
38138 int ecode1 = 0 ;
38139 PyObject * obj0 = 0 ;
38140 char * kwnames[] = {
38141 (char *) "doIt", NULL
38142 };
38143
38144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38145 if (obj0) {
38146 ecode1 = SWIG_AsVal_int(obj0, &val1);
38147 if (!SWIG_IsOK(ecode1)) {
38148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38149 }
38150 arg1 = static_cast< int >(val1);
38151 }
38152 {
38153 PyThreadState* __tstate = wxPyBeginAllowThreads();
38154 wxValidator::SetBellOnError(arg1);
38155 wxPyEndAllowThreads(__tstate);
38156 if (PyErr_Occurred()) SWIG_fail;
38157 }
38158 resultobj = SWIG_Py_Void();
38159 return resultobj;
38160 fail:
38161 return NULL;
38162 }
38163
38164
38165 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38166 PyObject *obj;
38167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38168 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38169 return SWIG_Py_Void();
38170 }
38171
38172 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38173 return SWIG_Python_InitShadowInstance(args);
38174 }
38175
38176 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38177 PyObject *resultobj = 0;
38178 wxPyValidator *result = 0 ;
38179
38180 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38181 {
38182 PyThreadState* __tstate = wxPyBeginAllowThreads();
38183 result = (wxPyValidator *)new wxPyValidator();
38184 wxPyEndAllowThreads(__tstate);
38185 if (PyErr_Occurred()) SWIG_fail;
38186 }
38187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38188 return resultobj;
38189 fail:
38190 return NULL;
38191 }
38192
38193
38194 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj = 0;
38196 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38197 PyObject *arg2 = (PyObject *) 0 ;
38198 PyObject *arg3 = (PyObject *) 0 ;
38199 int arg4 = (int) true ;
38200 void *argp1 = 0 ;
38201 int res1 = 0 ;
38202 int val4 ;
38203 int ecode4 = 0 ;
38204 PyObject * obj0 = 0 ;
38205 PyObject * obj1 = 0 ;
38206 PyObject * obj2 = 0 ;
38207 PyObject * obj3 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38216 }
38217 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38218 arg2 = obj1;
38219 arg3 = obj2;
38220 if (obj3) {
38221 ecode4 = SWIG_AsVal_int(obj3, &val4);
38222 if (!SWIG_IsOK(ecode4)) {
38223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38224 }
38225 arg4 = static_cast< int >(val4);
38226 }
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38230 wxPyEndAllowThreads(__tstate);
38231 if (PyErr_Occurred()) SWIG_fail;
38232 }
38233 resultobj = SWIG_Py_Void();
38234 return resultobj;
38235 fail:
38236 return NULL;
38237 }
38238
38239
38240 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38241 PyObject *obj;
38242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38243 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38244 return SWIG_Py_Void();
38245 }
38246
38247 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38248 return SWIG_Python_InitShadowInstance(args);
38249 }
38250
38251 SWIGINTERN int DefaultValidator_set(PyObject *) {
38252 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38253 return 1;
38254 }
38255
38256
38257 SWIGINTERN PyObject *DefaultValidator_get(void) {
38258 PyObject *pyobj = 0;
38259
38260 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38261 return pyobj;
38262 }
38263
38264
38265 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38266 PyObject *resultobj = 0;
38267 wxString const &arg1_defvalue = wxPyEmptyString ;
38268 wxString *arg1 = (wxString *) &arg1_defvalue ;
38269 long arg2 = (long) 0 ;
38270 wxMenu *result = 0 ;
38271 bool temp1 = false ;
38272 long val2 ;
38273 int ecode2 = 0 ;
38274 PyObject * obj0 = 0 ;
38275 PyObject * obj1 = 0 ;
38276 char * kwnames[] = {
38277 (char *) "title",(char *) "style", NULL
38278 };
38279
38280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38281 if (obj0) {
38282 {
38283 arg1 = wxString_in_helper(obj0);
38284 if (arg1 == NULL) SWIG_fail;
38285 temp1 = true;
38286 }
38287 }
38288 if (obj1) {
38289 ecode2 = SWIG_AsVal_long(obj1, &val2);
38290 if (!SWIG_IsOK(ecode2)) {
38291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38292 }
38293 arg2 = static_cast< long >(val2);
38294 }
38295 {
38296 if (!wxPyCheckForApp()) SWIG_fail;
38297 PyThreadState* __tstate = wxPyBeginAllowThreads();
38298 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38299 wxPyEndAllowThreads(__tstate);
38300 if (PyErr_Occurred()) SWIG_fail;
38301 }
38302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38303 {
38304 if (temp1)
38305 delete arg1;
38306 }
38307 return resultobj;
38308 fail:
38309 {
38310 if (temp1)
38311 delete arg1;
38312 }
38313 return NULL;
38314 }
38315
38316
38317 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38318 PyObject *resultobj = 0;
38319 wxMenu *arg1 = (wxMenu *) 0 ;
38320 int arg2 ;
38321 wxString *arg3 = 0 ;
38322 wxString const &arg4_defvalue = wxPyEmptyString ;
38323 wxString *arg4 = (wxString *) &arg4_defvalue ;
38324 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38325 wxMenuItem *result = 0 ;
38326 void *argp1 = 0 ;
38327 int res1 = 0 ;
38328 int val2 ;
38329 int ecode2 = 0 ;
38330 bool temp3 = false ;
38331 bool temp4 = false ;
38332 int val5 ;
38333 int ecode5 = 0 ;
38334 PyObject * obj0 = 0 ;
38335 PyObject * obj1 = 0 ;
38336 PyObject * obj2 = 0 ;
38337 PyObject * obj3 = 0 ;
38338 PyObject * obj4 = 0 ;
38339 char * kwnames[] = {
38340 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38341 };
38342
38343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38345 if (!SWIG_IsOK(res1)) {
38346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38347 }
38348 arg1 = reinterpret_cast< wxMenu * >(argp1);
38349 ecode2 = SWIG_AsVal_int(obj1, &val2);
38350 if (!SWIG_IsOK(ecode2)) {
38351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38352 }
38353 arg2 = static_cast< int >(val2);
38354 {
38355 arg3 = wxString_in_helper(obj2);
38356 if (arg3 == NULL) SWIG_fail;
38357 temp3 = true;
38358 }
38359 if (obj3) {
38360 {
38361 arg4 = wxString_in_helper(obj3);
38362 if (arg4 == NULL) SWIG_fail;
38363 temp4 = true;
38364 }
38365 }
38366 if (obj4) {
38367 ecode5 = SWIG_AsVal_int(obj4, &val5);
38368 if (!SWIG_IsOK(ecode5)) {
38369 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38370 }
38371 arg5 = static_cast< wxItemKind >(val5);
38372 }
38373 {
38374 PyThreadState* __tstate = wxPyBeginAllowThreads();
38375 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38376 wxPyEndAllowThreads(__tstate);
38377 if (PyErr_Occurred()) SWIG_fail;
38378 }
38379 {
38380 resultobj = wxPyMake_wxObject(result, (bool)0);
38381 }
38382 {
38383 if (temp3)
38384 delete arg3;
38385 }
38386 {
38387 if (temp4)
38388 delete arg4;
38389 }
38390 return resultobj;
38391 fail:
38392 {
38393 if (temp3)
38394 delete arg3;
38395 }
38396 {
38397 if (temp4)
38398 delete arg4;
38399 }
38400 return NULL;
38401 }
38402
38403
38404 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38405 PyObject *resultobj = 0;
38406 wxMenu *arg1 = (wxMenu *) 0 ;
38407 wxMenuItem *result = 0 ;
38408 void *argp1 = 0 ;
38409 int res1 = 0 ;
38410 PyObject *swig_obj[1] ;
38411
38412 if (!args) SWIG_fail;
38413 swig_obj[0] = args;
38414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38415 if (!SWIG_IsOK(res1)) {
38416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38417 }
38418 arg1 = reinterpret_cast< wxMenu * >(argp1);
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 result = (wxMenuItem *)(arg1)->AppendSeparator();
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 {
38426 resultobj = wxPyMake_wxObject(result, (bool)0);
38427 }
38428 return resultobj;
38429 fail:
38430 return NULL;
38431 }
38432
38433
38434 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38435 PyObject *resultobj = 0;
38436 wxMenu *arg1 = (wxMenu *) 0 ;
38437 int arg2 ;
38438 wxString *arg3 = 0 ;
38439 wxString const &arg4_defvalue = wxPyEmptyString ;
38440 wxString *arg4 = (wxString *) &arg4_defvalue ;
38441 wxMenuItem *result = 0 ;
38442 void *argp1 = 0 ;
38443 int res1 = 0 ;
38444 int val2 ;
38445 int ecode2 = 0 ;
38446 bool temp3 = false ;
38447 bool temp4 = false ;
38448 PyObject * obj0 = 0 ;
38449 PyObject * obj1 = 0 ;
38450 PyObject * obj2 = 0 ;
38451 PyObject * obj3 = 0 ;
38452 char * kwnames[] = {
38453 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38454 };
38455
38456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38458 if (!SWIG_IsOK(res1)) {
38459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38460 }
38461 arg1 = reinterpret_cast< wxMenu * >(argp1);
38462 ecode2 = SWIG_AsVal_int(obj1, &val2);
38463 if (!SWIG_IsOK(ecode2)) {
38464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38465 }
38466 arg2 = static_cast< int >(val2);
38467 {
38468 arg3 = wxString_in_helper(obj2);
38469 if (arg3 == NULL) SWIG_fail;
38470 temp3 = true;
38471 }
38472 if (obj3) {
38473 {
38474 arg4 = wxString_in_helper(obj3);
38475 if (arg4 == NULL) SWIG_fail;
38476 temp4 = true;
38477 }
38478 }
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38482 wxPyEndAllowThreads(__tstate);
38483 if (PyErr_Occurred()) SWIG_fail;
38484 }
38485 {
38486 resultobj = wxPyMake_wxObject(result, (bool)0);
38487 }
38488 {
38489 if (temp3)
38490 delete arg3;
38491 }
38492 {
38493 if (temp4)
38494 delete arg4;
38495 }
38496 return resultobj;
38497 fail:
38498 {
38499 if (temp3)
38500 delete arg3;
38501 }
38502 {
38503 if (temp4)
38504 delete arg4;
38505 }
38506 return NULL;
38507 }
38508
38509
38510 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj = 0;
38512 wxMenu *arg1 = (wxMenu *) 0 ;
38513 int arg2 ;
38514 wxString *arg3 = 0 ;
38515 wxString const &arg4_defvalue = wxPyEmptyString ;
38516 wxString *arg4 = (wxString *) &arg4_defvalue ;
38517 wxMenuItem *result = 0 ;
38518 void *argp1 = 0 ;
38519 int res1 = 0 ;
38520 int val2 ;
38521 int ecode2 = 0 ;
38522 bool temp3 = false ;
38523 bool temp4 = false ;
38524 PyObject * obj0 = 0 ;
38525 PyObject * obj1 = 0 ;
38526 PyObject * obj2 = 0 ;
38527 PyObject * obj3 = 0 ;
38528 char * kwnames[] = {
38529 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38530 };
38531
38532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38536 }
38537 arg1 = reinterpret_cast< wxMenu * >(argp1);
38538 ecode2 = SWIG_AsVal_int(obj1, &val2);
38539 if (!SWIG_IsOK(ecode2)) {
38540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38541 }
38542 arg2 = static_cast< int >(val2);
38543 {
38544 arg3 = wxString_in_helper(obj2);
38545 if (arg3 == NULL) SWIG_fail;
38546 temp3 = true;
38547 }
38548 if (obj3) {
38549 {
38550 arg4 = wxString_in_helper(obj3);
38551 if (arg4 == NULL) SWIG_fail;
38552 temp4 = true;
38553 }
38554 }
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38558 wxPyEndAllowThreads(__tstate);
38559 if (PyErr_Occurred()) SWIG_fail;
38560 }
38561 {
38562 resultobj = wxPyMake_wxObject(result, (bool)0);
38563 }
38564 {
38565 if (temp3)
38566 delete arg3;
38567 }
38568 {
38569 if (temp4)
38570 delete arg4;
38571 }
38572 return resultobj;
38573 fail:
38574 {
38575 if (temp3)
38576 delete arg3;
38577 }
38578 {
38579 if (temp4)
38580 delete arg4;
38581 }
38582 return NULL;
38583 }
38584
38585
38586 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38587 PyObject *resultobj = 0;
38588 wxMenu *arg1 = (wxMenu *) 0 ;
38589 int arg2 ;
38590 wxString *arg3 = 0 ;
38591 wxMenu *arg4 = (wxMenu *) 0 ;
38592 wxString const &arg5_defvalue = wxPyEmptyString ;
38593 wxString *arg5 = (wxString *) &arg5_defvalue ;
38594 wxMenuItem *result = 0 ;
38595 void *argp1 = 0 ;
38596 int res1 = 0 ;
38597 int val2 ;
38598 int ecode2 = 0 ;
38599 bool temp3 = false ;
38600 void *argp4 = 0 ;
38601 int res4 = 0 ;
38602 bool temp5 = false ;
38603 PyObject * obj0 = 0 ;
38604 PyObject * obj1 = 0 ;
38605 PyObject * obj2 = 0 ;
38606 PyObject * obj3 = 0 ;
38607 PyObject * obj4 = 0 ;
38608 char * kwnames[] = {
38609 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38610 };
38611
38612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38616 }
38617 arg1 = reinterpret_cast< wxMenu * >(argp1);
38618 ecode2 = SWIG_AsVal_int(obj1, &val2);
38619 if (!SWIG_IsOK(ecode2)) {
38620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38621 }
38622 arg2 = static_cast< int >(val2);
38623 {
38624 arg3 = wxString_in_helper(obj2);
38625 if (arg3 == NULL) SWIG_fail;
38626 temp3 = true;
38627 }
38628 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38629 if (!SWIG_IsOK(res4)) {
38630 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38631 }
38632 arg4 = reinterpret_cast< wxMenu * >(argp4);
38633 if (obj4) {
38634 {
38635 arg5 = wxString_in_helper(obj4);
38636 if (arg5 == NULL) SWIG_fail;
38637 temp5 = true;
38638 }
38639 }
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38643 wxPyEndAllowThreads(__tstate);
38644 if (PyErr_Occurred()) SWIG_fail;
38645 }
38646 {
38647 resultobj = wxPyMake_wxObject(result, (bool)0);
38648 }
38649 {
38650 if (temp3)
38651 delete arg3;
38652 }
38653 {
38654 if (temp5)
38655 delete arg5;
38656 }
38657 return resultobj;
38658 fail:
38659 {
38660 if (temp3)
38661 delete arg3;
38662 }
38663 {
38664 if (temp5)
38665 delete arg5;
38666 }
38667 return NULL;
38668 }
38669
38670
38671 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38672 PyObject *resultobj = 0;
38673 wxMenu *arg1 = (wxMenu *) 0 ;
38674 wxMenu *arg2 = (wxMenu *) 0 ;
38675 wxString *arg3 = 0 ;
38676 wxString const &arg4_defvalue = wxPyEmptyString ;
38677 wxString *arg4 = (wxString *) &arg4_defvalue ;
38678 wxMenuItem *result = 0 ;
38679 void *argp1 = 0 ;
38680 int res1 = 0 ;
38681 void *argp2 = 0 ;
38682 int res2 = 0 ;
38683 bool temp3 = false ;
38684 bool temp4 = false ;
38685 PyObject * obj0 = 0 ;
38686 PyObject * obj1 = 0 ;
38687 PyObject * obj2 = 0 ;
38688 PyObject * obj3 = 0 ;
38689 char * kwnames[] = {
38690 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38691 };
38692
38693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38695 if (!SWIG_IsOK(res1)) {
38696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38697 }
38698 arg1 = reinterpret_cast< wxMenu * >(argp1);
38699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38700 if (!SWIG_IsOK(res2)) {
38701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38702 }
38703 arg2 = reinterpret_cast< wxMenu * >(argp2);
38704 {
38705 arg3 = wxString_in_helper(obj2);
38706 if (arg3 == NULL) SWIG_fail;
38707 temp3 = true;
38708 }
38709 if (obj3) {
38710 {
38711 arg4 = wxString_in_helper(obj3);
38712 if (arg4 == NULL) SWIG_fail;
38713 temp4 = true;
38714 }
38715 }
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 {
38723 resultobj = wxPyMake_wxObject(result, (bool)0);
38724 }
38725 {
38726 if (temp3)
38727 delete arg3;
38728 }
38729 {
38730 if (temp4)
38731 delete arg4;
38732 }
38733 return resultobj;
38734 fail:
38735 {
38736 if (temp3)
38737 delete arg3;
38738 }
38739 {
38740 if (temp4)
38741 delete arg4;
38742 }
38743 return NULL;
38744 }
38745
38746
38747 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38748 PyObject *resultobj = 0;
38749 wxMenu *arg1 = (wxMenu *) 0 ;
38750 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38751 wxMenuItem *result = 0 ;
38752 void *argp1 = 0 ;
38753 int res1 = 0 ;
38754 int res2 = 0 ;
38755 PyObject * obj0 = 0 ;
38756 PyObject * obj1 = 0 ;
38757 char * kwnames[] = {
38758 (char *) "self",(char *) "item", NULL
38759 };
38760
38761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38763 if (!SWIG_IsOK(res1)) {
38764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38765 }
38766 arg1 = reinterpret_cast< wxMenu * >(argp1);
38767 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38768 if (!SWIG_IsOK(res2)) {
38769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38770 }
38771 {
38772 PyThreadState* __tstate = wxPyBeginAllowThreads();
38773 result = (wxMenuItem *)(arg1)->Append(arg2);
38774 wxPyEndAllowThreads(__tstate);
38775 if (PyErr_Occurred()) SWIG_fail;
38776 }
38777 {
38778 resultobj = wxPyMake_wxObject(result, (bool)0);
38779 }
38780 return resultobj;
38781 fail:
38782 return NULL;
38783 }
38784
38785
38786 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38787 PyObject *resultobj = 0;
38788 wxMenu *arg1 = (wxMenu *) 0 ;
38789 size_t arg2 ;
38790 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38791 wxMenuItem *result = 0 ;
38792 void *argp1 = 0 ;
38793 int res1 = 0 ;
38794 size_t val2 ;
38795 int ecode2 = 0 ;
38796 int res3 = 0 ;
38797 PyObject * obj0 = 0 ;
38798 PyObject * obj1 = 0 ;
38799 PyObject * obj2 = 0 ;
38800 char * kwnames[] = {
38801 (char *) "self",(char *) "pos",(char *) "item", NULL
38802 };
38803
38804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38806 if (!SWIG_IsOK(res1)) {
38807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38808 }
38809 arg1 = reinterpret_cast< wxMenu * >(argp1);
38810 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38811 if (!SWIG_IsOK(ecode2)) {
38812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38813 }
38814 arg2 = static_cast< size_t >(val2);
38815 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38816 if (!SWIG_IsOK(res3)) {
38817 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38818 }
38819 {
38820 PyThreadState* __tstate = wxPyBeginAllowThreads();
38821 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38822 wxPyEndAllowThreads(__tstate);
38823 if (PyErr_Occurred()) SWIG_fail;
38824 }
38825 {
38826 resultobj = wxPyMake_wxObject(result, (bool)0);
38827 }
38828 return resultobj;
38829 fail:
38830 return NULL;
38831 }
38832
38833
38834 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38835 PyObject *resultobj = 0;
38836 wxMenu *arg1 = (wxMenu *) 0 ;
38837 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38838 wxMenuItem *result = 0 ;
38839 void *argp1 = 0 ;
38840 int res1 = 0 ;
38841 int res2 = 0 ;
38842 PyObject * obj0 = 0 ;
38843 PyObject * obj1 = 0 ;
38844 char * kwnames[] = {
38845 (char *) "self",(char *) "item", NULL
38846 };
38847
38848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38850 if (!SWIG_IsOK(res1)) {
38851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38852 }
38853 arg1 = reinterpret_cast< wxMenu * >(argp1);
38854 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38855 if (!SWIG_IsOK(res2)) {
38856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38857 }
38858 {
38859 PyThreadState* __tstate = wxPyBeginAllowThreads();
38860 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38861 wxPyEndAllowThreads(__tstate);
38862 if (PyErr_Occurred()) SWIG_fail;
38863 }
38864 {
38865 resultobj = wxPyMake_wxObject(result, (bool)0);
38866 }
38867 return resultobj;
38868 fail:
38869 return NULL;
38870 }
38871
38872
38873 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38874 PyObject *resultobj = 0;
38875 wxMenu *arg1 = (wxMenu *) 0 ;
38876 void *argp1 = 0 ;
38877 int res1 = 0 ;
38878 PyObject *swig_obj[1] ;
38879
38880 if (!args) SWIG_fail;
38881 swig_obj[0] = args;
38882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38883 if (!SWIG_IsOK(res1)) {
38884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38885 }
38886 arg1 = reinterpret_cast< wxMenu * >(argp1);
38887 {
38888 PyThreadState* __tstate = wxPyBeginAllowThreads();
38889 (arg1)->Break();
38890 wxPyEndAllowThreads(__tstate);
38891 if (PyErr_Occurred()) SWIG_fail;
38892 }
38893 resultobj = SWIG_Py_Void();
38894 return resultobj;
38895 fail:
38896 return NULL;
38897 }
38898
38899
38900 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38901 PyObject *resultobj = 0;
38902 wxMenu *arg1 = (wxMenu *) 0 ;
38903 size_t arg2 ;
38904 int arg3 ;
38905 wxString *arg4 = 0 ;
38906 wxString const &arg5_defvalue = wxPyEmptyString ;
38907 wxString *arg5 = (wxString *) &arg5_defvalue ;
38908 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38909 wxMenuItem *result = 0 ;
38910 void *argp1 = 0 ;
38911 int res1 = 0 ;
38912 size_t val2 ;
38913 int ecode2 = 0 ;
38914 int val3 ;
38915 int ecode3 = 0 ;
38916 bool temp4 = false ;
38917 bool temp5 = false ;
38918 int val6 ;
38919 int ecode6 = 0 ;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 PyObject * obj2 = 0 ;
38923 PyObject * obj3 = 0 ;
38924 PyObject * obj4 = 0 ;
38925 PyObject * obj5 = 0 ;
38926 char * kwnames[] = {
38927 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38928 };
38929
38930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38932 if (!SWIG_IsOK(res1)) {
38933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38934 }
38935 arg1 = reinterpret_cast< wxMenu * >(argp1);
38936 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38937 if (!SWIG_IsOK(ecode2)) {
38938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38939 }
38940 arg2 = static_cast< size_t >(val2);
38941 ecode3 = SWIG_AsVal_int(obj2, &val3);
38942 if (!SWIG_IsOK(ecode3)) {
38943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38944 }
38945 arg3 = static_cast< int >(val3);
38946 {
38947 arg4 = wxString_in_helper(obj3);
38948 if (arg4 == NULL) SWIG_fail;
38949 temp4 = true;
38950 }
38951 if (obj4) {
38952 {
38953 arg5 = wxString_in_helper(obj4);
38954 if (arg5 == NULL) SWIG_fail;
38955 temp5 = true;
38956 }
38957 }
38958 if (obj5) {
38959 ecode6 = SWIG_AsVal_int(obj5, &val6);
38960 if (!SWIG_IsOK(ecode6)) {
38961 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38962 }
38963 arg6 = static_cast< wxItemKind >(val6);
38964 }
38965 {
38966 PyThreadState* __tstate = wxPyBeginAllowThreads();
38967 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38968 wxPyEndAllowThreads(__tstate);
38969 if (PyErr_Occurred()) SWIG_fail;
38970 }
38971 {
38972 resultobj = wxPyMake_wxObject(result, (bool)0);
38973 }
38974 {
38975 if (temp4)
38976 delete arg4;
38977 }
38978 {
38979 if (temp5)
38980 delete arg5;
38981 }
38982 return resultobj;
38983 fail:
38984 {
38985 if (temp4)
38986 delete arg4;
38987 }
38988 {
38989 if (temp5)
38990 delete arg5;
38991 }
38992 return NULL;
38993 }
38994
38995
38996 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38997 PyObject *resultobj = 0;
38998 wxMenu *arg1 = (wxMenu *) 0 ;
38999 size_t arg2 ;
39000 wxMenuItem *result = 0 ;
39001 void *argp1 = 0 ;
39002 int res1 = 0 ;
39003 size_t val2 ;
39004 int ecode2 = 0 ;
39005 PyObject * obj0 = 0 ;
39006 PyObject * obj1 = 0 ;
39007 char * kwnames[] = {
39008 (char *) "self",(char *) "pos", NULL
39009 };
39010
39011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39013 if (!SWIG_IsOK(res1)) {
39014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39015 }
39016 arg1 = reinterpret_cast< wxMenu * >(argp1);
39017 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39018 if (!SWIG_IsOK(ecode2)) {
39019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39020 }
39021 arg2 = static_cast< size_t >(val2);
39022 {
39023 PyThreadState* __tstate = wxPyBeginAllowThreads();
39024 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39025 wxPyEndAllowThreads(__tstate);
39026 if (PyErr_Occurred()) SWIG_fail;
39027 }
39028 {
39029 resultobj = wxPyMake_wxObject(result, (bool)0);
39030 }
39031 return resultobj;
39032 fail:
39033 return NULL;
39034 }
39035
39036
39037 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39038 PyObject *resultobj = 0;
39039 wxMenu *arg1 = (wxMenu *) 0 ;
39040 size_t arg2 ;
39041 int arg3 ;
39042 wxString *arg4 = 0 ;
39043 wxString const &arg5_defvalue = wxPyEmptyString ;
39044 wxString *arg5 = (wxString *) &arg5_defvalue ;
39045 wxMenuItem *result = 0 ;
39046 void *argp1 = 0 ;
39047 int res1 = 0 ;
39048 size_t val2 ;
39049 int ecode2 = 0 ;
39050 int val3 ;
39051 int ecode3 = 0 ;
39052 bool temp4 = false ;
39053 bool temp5 = false ;
39054 PyObject * obj0 = 0 ;
39055 PyObject * obj1 = 0 ;
39056 PyObject * obj2 = 0 ;
39057 PyObject * obj3 = 0 ;
39058 PyObject * obj4 = 0 ;
39059 char * kwnames[] = {
39060 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39061 };
39062
39063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39065 if (!SWIG_IsOK(res1)) {
39066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39067 }
39068 arg1 = reinterpret_cast< wxMenu * >(argp1);
39069 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39070 if (!SWIG_IsOK(ecode2)) {
39071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39072 }
39073 arg2 = static_cast< size_t >(val2);
39074 ecode3 = SWIG_AsVal_int(obj2, &val3);
39075 if (!SWIG_IsOK(ecode3)) {
39076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39077 }
39078 arg3 = static_cast< int >(val3);
39079 {
39080 arg4 = wxString_in_helper(obj3);
39081 if (arg4 == NULL) SWIG_fail;
39082 temp4 = true;
39083 }
39084 if (obj4) {
39085 {
39086 arg5 = wxString_in_helper(obj4);
39087 if (arg5 == NULL) SWIG_fail;
39088 temp5 = true;
39089 }
39090 }
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 {
39098 resultobj = wxPyMake_wxObject(result, (bool)0);
39099 }
39100 {
39101 if (temp4)
39102 delete arg4;
39103 }
39104 {
39105 if (temp5)
39106 delete arg5;
39107 }
39108 return resultobj;
39109 fail:
39110 {
39111 if (temp4)
39112 delete arg4;
39113 }
39114 {
39115 if (temp5)
39116 delete arg5;
39117 }
39118 return NULL;
39119 }
39120
39121
39122 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39123 PyObject *resultobj = 0;
39124 wxMenu *arg1 = (wxMenu *) 0 ;
39125 size_t arg2 ;
39126 int arg3 ;
39127 wxString *arg4 = 0 ;
39128 wxString const &arg5_defvalue = wxPyEmptyString ;
39129 wxString *arg5 = (wxString *) &arg5_defvalue ;
39130 wxMenuItem *result = 0 ;
39131 void *argp1 = 0 ;
39132 int res1 = 0 ;
39133 size_t val2 ;
39134 int ecode2 = 0 ;
39135 int val3 ;
39136 int ecode3 = 0 ;
39137 bool temp4 = false ;
39138 bool temp5 = false ;
39139 PyObject * obj0 = 0 ;
39140 PyObject * obj1 = 0 ;
39141 PyObject * obj2 = 0 ;
39142 PyObject * obj3 = 0 ;
39143 PyObject * obj4 = 0 ;
39144 char * kwnames[] = {
39145 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39146 };
39147
39148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39150 if (!SWIG_IsOK(res1)) {
39151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39152 }
39153 arg1 = reinterpret_cast< wxMenu * >(argp1);
39154 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39155 if (!SWIG_IsOK(ecode2)) {
39156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39157 }
39158 arg2 = static_cast< size_t >(val2);
39159 ecode3 = SWIG_AsVal_int(obj2, &val3);
39160 if (!SWIG_IsOK(ecode3)) {
39161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39162 }
39163 arg3 = static_cast< int >(val3);
39164 {
39165 arg4 = wxString_in_helper(obj3);
39166 if (arg4 == NULL) SWIG_fail;
39167 temp4 = true;
39168 }
39169 if (obj4) {
39170 {
39171 arg5 = wxString_in_helper(obj4);
39172 if (arg5 == NULL) SWIG_fail;
39173 temp5 = true;
39174 }
39175 }
39176 {
39177 PyThreadState* __tstate = wxPyBeginAllowThreads();
39178 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39179 wxPyEndAllowThreads(__tstate);
39180 if (PyErr_Occurred()) SWIG_fail;
39181 }
39182 {
39183 resultobj = wxPyMake_wxObject(result, (bool)0);
39184 }
39185 {
39186 if (temp4)
39187 delete arg4;
39188 }
39189 {
39190 if (temp5)
39191 delete arg5;
39192 }
39193 return resultobj;
39194 fail:
39195 {
39196 if (temp4)
39197 delete arg4;
39198 }
39199 {
39200 if (temp5)
39201 delete arg5;
39202 }
39203 return NULL;
39204 }
39205
39206
39207 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39208 PyObject *resultobj = 0;
39209 wxMenu *arg1 = (wxMenu *) 0 ;
39210 size_t arg2 ;
39211 int arg3 ;
39212 wxString *arg4 = 0 ;
39213 wxMenu *arg5 = (wxMenu *) 0 ;
39214 wxString const &arg6_defvalue = wxPyEmptyString ;
39215 wxString *arg6 = (wxString *) &arg6_defvalue ;
39216 wxMenuItem *result = 0 ;
39217 void *argp1 = 0 ;
39218 int res1 = 0 ;
39219 size_t val2 ;
39220 int ecode2 = 0 ;
39221 int val3 ;
39222 int ecode3 = 0 ;
39223 bool temp4 = false ;
39224 void *argp5 = 0 ;
39225 int res5 = 0 ;
39226 bool temp6 = false ;
39227 PyObject * obj0 = 0 ;
39228 PyObject * obj1 = 0 ;
39229 PyObject * obj2 = 0 ;
39230 PyObject * obj3 = 0 ;
39231 PyObject * obj4 = 0 ;
39232 PyObject * obj5 = 0 ;
39233 char * kwnames[] = {
39234 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39235 };
39236
39237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39239 if (!SWIG_IsOK(res1)) {
39240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39241 }
39242 arg1 = reinterpret_cast< wxMenu * >(argp1);
39243 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39244 if (!SWIG_IsOK(ecode2)) {
39245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39246 }
39247 arg2 = static_cast< size_t >(val2);
39248 ecode3 = SWIG_AsVal_int(obj2, &val3);
39249 if (!SWIG_IsOK(ecode3)) {
39250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39251 }
39252 arg3 = static_cast< int >(val3);
39253 {
39254 arg4 = wxString_in_helper(obj3);
39255 if (arg4 == NULL) SWIG_fail;
39256 temp4 = true;
39257 }
39258 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39259 if (!SWIG_IsOK(res5)) {
39260 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39261 }
39262 arg5 = reinterpret_cast< wxMenu * >(argp5);
39263 if (obj5) {
39264 {
39265 arg6 = wxString_in_helper(obj5);
39266 if (arg6 == NULL) SWIG_fail;
39267 temp6 = true;
39268 }
39269 }
39270 {
39271 PyThreadState* __tstate = wxPyBeginAllowThreads();
39272 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39273 wxPyEndAllowThreads(__tstate);
39274 if (PyErr_Occurred()) SWIG_fail;
39275 }
39276 {
39277 resultobj = wxPyMake_wxObject(result, (bool)0);
39278 }
39279 {
39280 if (temp4)
39281 delete arg4;
39282 }
39283 {
39284 if (temp6)
39285 delete arg6;
39286 }
39287 return resultobj;
39288 fail:
39289 {
39290 if (temp4)
39291 delete arg4;
39292 }
39293 {
39294 if (temp6)
39295 delete arg6;
39296 }
39297 return NULL;
39298 }
39299
39300
39301 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39302 PyObject *resultobj = 0;
39303 wxMenu *arg1 = (wxMenu *) 0 ;
39304 int arg2 ;
39305 wxString *arg3 = 0 ;
39306 wxString const &arg4_defvalue = wxPyEmptyString ;
39307 wxString *arg4 = (wxString *) &arg4_defvalue ;
39308 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39309 wxMenuItem *result = 0 ;
39310 void *argp1 = 0 ;
39311 int res1 = 0 ;
39312 int val2 ;
39313 int ecode2 = 0 ;
39314 bool temp3 = false ;
39315 bool temp4 = false ;
39316 int val5 ;
39317 int ecode5 = 0 ;
39318 PyObject * obj0 = 0 ;
39319 PyObject * obj1 = 0 ;
39320 PyObject * obj2 = 0 ;
39321 PyObject * obj3 = 0 ;
39322 PyObject * obj4 = 0 ;
39323 char * kwnames[] = {
39324 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39325 };
39326
39327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39329 if (!SWIG_IsOK(res1)) {
39330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39331 }
39332 arg1 = reinterpret_cast< wxMenu * >(argp1);
39333 ecode2 = SWIG_AsVal_int(obj1, &val2);
39334 if (!SWIG_IsOK(ecode2)) {
39335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39336 }
39337 arg2 = static_cast< int >(val2);
39338 {
39339 arg3 = wxString_in_helper(obj2);
39340 if (arg3 == NULL) SWIG_fail;
39341 temp3 = true;
39342 }
39343 if (obj3) {
39344 {
39345 arg4 = wxString_in_helper(obj3);
39346 if (arg4 == NULL) SWIG_fail;
39347 temp4 = true;
39348 }
39349 }
39350 if (obj4) {
39351 ecode5 = SWIG_AsVal_int(obj4, &val5);
39352 if (!SWIG_IsOK(ecode5)) {
39353 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39354 }
39355 arg5 = static_cast< wxItemKind >(val5);
39356 }
39357 {
39358 PyThreadState* __tstate = wxPyBeginAllowThreads();
39359 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39360 wxPyEndAllowThreads(__tstate);
39361 if (PyErr_Occurred()) SWIG_fail;
39362 }
39363 {
39364 resultobj = wxPyMake_wxObject(result, (bool)0);
39365 }
39366 {
39367 if (temp3)
39368 delete arg3;
39369 }
39370 {
39371 if (temp4)
39372 delete arg4;
39373 }
39374 return resultobj;
39375 fail:
39376 {
39377 if (temp3)
39378 delete arg3;
39379 }
39380 {
39381 if (temp4)
39382 delete arg4;
39383 }
39384 return NULL;
39385 }
39386
39387
39388 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39389 PyObject *resultobj = 0;
39390 wxMenu *arg1 = (wxMenu *) 0 ;
39391 wxMenuItem *result = 0 ;
39392 void *argp1 = 0 ;
39393 int res1 = 0 ;
39394 PyObject *swig_obj[1] ;
39395
39396 if (!args) SWIG_fail;
39397 swig_obj[0] = args;
39398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39399 if (!SWIG_IsOK(res1)) {
39400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39401 }
39402 arg1 = reinterpret_cast< wxMenu * >(argp1);
39403 {
39404 PyThreadState* __tstate = wxPyBeginAllowThreads();
39405 result = (wxMenuItem *)(arg1)->PrependSeparator();
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 {
39410 resultobj = wxPyMake_wxObject(result, (bool)0);
39411 }
39412 return resultobj;
39413 fail:
39414 return NULL;
39415 }
39416
39417
39418 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39419 PyObject *resultobj = 0;
39420 wxMenu *arg1 = (wxMenu *) 0 ;
39421 int arg2 ;
39422 wxString *arg3 = 0 ;
39423 wxString const &arg4_defvalue = wxPyEmptyString ;
39424 wxString *arg4 = (wxString *) &arg4_defvalue ;
39425 wxMenuItem *result = 0 ;
39426 void *argp1 = 0 ;
39427 int res1 = 0 ;
39428 int val2 ;
39429 int ecode2 = 0 ;
39430 bool temp3 = false ;
39431 bool temp4 = false ;
39432 PyObject * obj0 = 0 ;
39433 PyObject * obj1 = 0 ;
39434 PyObject * obj2 = 0 ;
39435 PyObject * obj3 = 0 ;
39436 char * kwnames[] = {
39437 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39438 };
39439
39440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39442 if (!SWIG_IsOK(res1)) {
39443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39444 }
39445 arg1 = reinterpret_cast< wxMenu * >(argp1);
39446 ecode2 = SWIG_AsVal_int(obj1, &val2);
39447 if (!SWIG_IsOK(ecode2)) {
39448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39449 }
39450 arg2 = static_cast< int >(val2);
39451 {
39452 arg3 = wxString_in_helper(obj2);
39453 if (arg3 == NULL) SWIG_fail;
39454 temp3 = true;
39455 }
39456 if (obj3) {
39457 {
39458 arg4 = wxString_in_helper(obj3);
39459 if (arg4 == NULL) SWIG_fail;
39460 temp4 = true;
39461 }
39462 }
39463 {
39464 PyThreadState* __tstate = wxPyBeginAllowThreads();
39465 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39466 wxPyEndAllowThreads(__tstate);
39467 if (PyErr_Occurred()) SWIG_fail;
39468 }
39469 {
39470 resultobj = wxPyMake_wxObject(result, (bool)0);
39471 }
39472 {
39473 if (temp3)
39474 delete arg3;
39475 }
39476 {
39477 if (temp4)
39478 delete arg4;
39479 }
39480 return resultobj;
39481 fail:
39482 {
39483 if (temp3)
39484 delete arg3;
39485 }
39486 {
39487 if (temp4)
39488 delete arg4;
39489 }
39490 return NULL;
39491 }
39492
39493
39494 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39495 PyObject *resultobj = 0;
39496 wxMenu *arg1 = (wxMenu *) 0 ;
39497 int arg2 ;
39498 wxString *arg3 = 0 ;
39499 wxString const &arg4_defvalue = wxPyEmptyString ;
39500 wxString *arg4 = (wxString *) &arg4_defvalue ;
39501 wxMenuItem *result = 0 ;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 int val2 ;
39505 int ecode2 = 0 ;
39506 bool temp3 = false ;
39507 bool temp4 = false ;
39508 PyObject * obj0 = 0 ;
39509 PyObject * obj1 = 0 ;
39510 PyObject * obj2 = 0 ;
39511 PyObject * obj3 = 0 ;
39512 char * kwnames[] = {
39513 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39514 };
39515
39516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39518 if (!SWIG_IsOK(res1)) {
39519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39520 }
39521 arg1 = reinterpret_cast< wxMenu * >(argp1);
39522 ecode2 = SWIG_AsVal_int(obj1, &val2);
39523 if (!SWIG_IsOK(ecode2)) {
39524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39525 }
39526 arg2 = static_cast< int >(val2);
39527 {
39528 arg3 = wxString_in_helper(obj2);
39529 if (arg3 == NULL) SWIG_fail;
39530 temp3 = true;
39531 }
39532 if (obj3) {
39533 {
39534 arg4 = wxString_in_helper(obj3);
39535 if (arg4 == NULL) SWIG_fail;
39536 temp4 = true;
39537 }
39538 }
39539 {
39540 PyThreadState* __tstate = wxPyBeginAllowThreads();
39541 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39542 wxPyEndAllowThreads(__tstate);
39543 if (PyErr_Occurred()) SWIG_fail;
39544 }
39545 {
39546 resultobj = wxPyMake_wxObject(result, (bool)0);
39547 }
39548 {
39549 if (temp3)
39550 delete arg3;
39551 }
39552 {
39553 if (temp4)
39554 delete arg4;
39555 }
39556 return resultobj;
39557 fail:
39558 {
39559 if (temp3)
39560 delete arg3;
39561 }
39562 {
39563 if (temp4)
39564 delete arg4;
39565 }
39566 return NULL;
39567 }
39568
39569
39570 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39571 PyObject *resultobj = 0;
39572 wxMenu *arg1 = (wxMenu *) 0 ;
39573 int arg2 ;
39574 wxString *arg3 = 0 ;
39575 wxMenu *arg4 = (wxMenu *) 0 ;
39576 wxString const &arg5_defvalue = wxPyEmptyString ;
39577 wxString *arg5 = (wxString *) &arg5_defvalue ;
39578 wxMenuItem *result = 0 ;
39579 void *argp1 = 0 ;
39580 int res1 = 0 ;
39581 int val2 ;
39582 int ecode2 = 0 ;
39583 bool temp3 = false ;
39584 void *argp4 = 0 ;
39585 int res4 = 0 ;
39586 bool temp5 = false ;
39587 PyObject * obj0 = 0 ;
39588 PyObject * obj1 = 0 ;
39589 PyObject * obj2 = 0 ;
39590 PyObject * obj3 = 0 ;
39591 PyObject * obj4 = 0 ;
39592 char * kwnames[] = {
39593 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39594 };
39595
39596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39598 if (!SWIG_IsOK(res1)) {
39599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39600 }
39601 arg1 = reinterpret_cast< wxMenu * >(argp1);
39602 ecode2 = SWIG_AsVal_int(obj1, &val2);
39603 if (!SWIG_IsOK(ecode2)) {
39604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39605 }
39606 arg2 = static_cast< int >(val2);
39607 {
39608 arg3 = wxString_in_helper(obj2);
39609 if (arg3 == NULL) SWIG_fail;
39610 temp3 = true;
39611 }
39612 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39613 if (!SWIG_IsOK(res4)) {
39614 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39615 }
39616 arg4 = reinterpret_cast< wxMenu * >(argp4);
39617 if (obj4) {
39618 {
39619 arg5 = wxString_in_helper(obj4);
39620 if (arg5 == NULL) SWIG_fail;
39621 temp5 = true;
39622 }
39623 }
39624 {
39625 PyThreadState* __tstate = wxPyBeginAllowThreads();
39626 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39627 wxPyEndAllowThreads(__tstate);
39628 if (PyErr_Occurred()) SWIG_fail;
39629 }
39630 {
39631 resultobj = wxPyMake_wxObject(result, (bool)0);
39632 }
39633 {
39634 if (temp3)
39635 delete arg3;
39636 }
39637 {
39638 if (temp5)
39639 delete arg5;
39640 }
39641 return resultobj;
39642 fail:
39643 {
39644 if (temp3)
39645 delete arg3;
39646 }
39647 {
39648 if (temp5)
39649 delete arg5;
39650 }
39651 return NULL;
39652 }
39653
39654
39655 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39656 PyObject *resultobj = 0;
39657 wxMenu *arg1 = (wxMenu *) 0 ;
39658 int arg2 ;
39659 wxMenuItem *result = 0 ;
39660 void *argp1 = 0 ;
39661 int res1 = 0 ;
39662 int val2 ;
39663 int ecode2 = 0 ;
39664 PyObject * obj0 = 0 ;
39665 PyObject * obj1 = 0 ;
39666 char * kwnames[] = {
39667 (char *) "self",(char *) "id", NULL
39668 };
39669
39670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39672 if (!SWIG_IsOK(res1)) {
39673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39674 }
39675 arg1 = reinterpret_cast< wxMenu * >(argp1);
39676 ecode2 = SWIG_AsVal_int(obj1, &val2);
39677 if (!SWIG_IsOK(ecode2)) {
39678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39679 }
39680 arg2 = static_cast< int >(val2);
39681 {
39682 PyThreadState* __tstate = wxPyBeginAllowThreads();
39683 result = (wxMenuItem *)(arg1)->Remove(arg2);
39684 wxPyEndAllowThreads(__tstate);
39685 if (PyErr_Occurred()) SWIG_fail;
39686 }
39687 {
39688 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39689 }
39690 return resultobj;
39691 fail:
39692 return NULL;
39693 }
39694
39695
39696 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39697 PyObject *resultobj = 0;
39698 wxMenu *arg1 = (wxMenu *) 0 ;
39699 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39700 wxMenuItem *result = 0 ;
39701 void *argp1 = 0 ;
39702 int res1 = 0 ;
39703 void *argp2 = 0 ;
39704 int res2 = 0 ;
39705 PyObject * obj0 = 0 ;
39706 PyObject * obj1 = 0 ;
39707 char * kwnames[] = {
39708 (char *) "self",(char *) "item", NULL
39709 };
39710
39711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39713 if (!SWIG_IsOK(res1)) {
39714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39715 }
39716 arg1 = reinterpret_cast< wxMenu * >(argp1);
39717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39718 if (!SWIG_IsOK(res2)) {
39719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39720 }
39721 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 result = (wxMenuItem *)(arg1)->Remove(arg2);
39725 wxPyEndAllowThreads(__tstate);
39726 if (PyErr_Occurred()) SWIG_fail;
39727 }
39728 {
39729 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39730 }
39731 return resultobj;
39732 fail:
39733 return NULL;
39734 }
39735
39736
39737 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39738 PyObject *resultobj = 0;
39739 wxMenu *arg1 = (wxMenu *) 0 ;
39740 int arg2 ;
39741 bool result;
39742 void *argp1 = 0 ;
39743 int res1 = 0 ;
39744 int val2 ;
39745 int ecode2 = 0 ;
39746 PyObject * obj0 = 0 ;
39747 PyObject * obj1 = 0 ;
39748 char * kwnames[] = {
39749 (char *) "self",(char *) "id", NULL
39750 };
39751
39752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39754 if (!SWIG_IsOK(res1)) {
39755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39756 }
39757 arg1 = reinterpret_cast< wxMenu * >(argp1);
39758 ecode2 = SWIG_AsVal_int(obj1, &val2);
39759 if (!SWIG_IsOK(ecode2)) {
39760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39761 }
39762 arg2 = static_cast< int >(val2);
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 result = (bool)(arg1)->Delete(arg2);
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 {
39770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39771 }
39772 return resultobj;
39773 fail:
39774 return NULL;
39775 }
39776
39777
39778 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39779 PyObject *resultobj = 0;
39780 wxMenu *arg1 = (wxMenu *) 0 ;
39781 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39782 bool result;
39783 void *argp1 = 0 ;
39784 int res1 = 0 ;
39785 void *argp2 = 0 ;
39786 int res2 = 0 ;
39787 PyObject * obj0 = 0 ;
39788 PyObject * obj1 = 0 ;
39789 char * kwnames[] = {
39790 (char *) "self",(char *) "item", NULL
39791 };
39792
39793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39795 if (!SWIG_IsOK(res1)) {
39796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39797 }
39798 arg1 = reinterpret_cast< wxMenu * >(argp1);
39799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39800 if (!SWIG_IsOK(res2)) {
39801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39802 }
39803 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39804 {
39805 PyThreadState* __tstate = wxPyBeginAllowThreads();
39806 result = (bool)(arg1)->Delete(arg2);
39807 wxPyEndAllowThreads(__tstate);
39808 if (PyErr_Occurred()) SWIG_fail;
39809 }
39810 {
39811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39812 }
39813 return resultobj;
39814 fail:
39815 return NULL;
39816 }
39817
39818
39819 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39820 PyObject *resultobj = 0;
39821 wxMenu *arg1 = (wxMenu *) 0 ;
39822 void *argp1 = 0 ;
39823 int res1 = 0 ;
39824 PyObject *swig_obj[1] ;
39825
39826 if (!args) SWIG_fail;
39827 swig_obj[0] = args;
39828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39829 if (!SWIG_IsOK(res1)) {
39830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39831 }
39832 arg1 = reinterpret_cast< wxMenu * >(argp1);
39833 {
39834 PyThreadState* __tstate = wxPyBeginAllowThreads();
39835 wxMenu_Destroy(arg1);
39836 wxPyEndAllowThreads(__tstate);
39837 if (PyErr_Occurred()) SWIG_fail;
39838 }
39839 resultobj = SWIG_Py_Void();
39840 return resultobj;
39841 fail:
39842 return NULL;
39843 }
39844
39845
39846 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39847 PyObject *resultobj = 0;
39848 wxMenu *arg1 = (wxMenu *) 0 ;
39849 int arg2 ;
39850 bool result;
39851 void *argp1 = 0 ;
39852 int res1 = 0 ;
39853 int val2 ;
39854 int ecode2 = 0 ;
39855 PyObject * obj0 = 0 ;
39856 PyObject * obj1 = 0 ;
39857 char * kwnames[] = {
39858 (char *) "self",(char *) "id", NULL
39859 };
39860
39861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39863 if (!SWIG_IsOK(res1)) {
39864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39865 }
39866 arg1 = reinterpret_cast< wxMenu * >(argp1);
39867 ecode2 = SWIG_AsVal_int(obj1, &val2);
39868 if (!SWIG_IsOK(ecode2)) {
39869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39870 }
39871 arg2 = static_cast< int >(val2);
39872 {
39873 PyThreadState* __tstate = wxPyBeginAllowThreads();
39874 result = (bool)(arg1)->Destroy(arg2);
39875 wxPyEndAllowThreads(__tstate);
39876 if (PyErr_Occurred()) SWIG_fail;
39877 }
39878 {
39879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39880 }
39881 return resultobj;
39882 fail:
39883 return NULL;
39884 }
39885
39886
39887 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39888 PyObject *resultobj = 0;
39889 wxMenu *arg1 = (wxMenu *) 0 ;
39890 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39891 bool result;
39892 void *argp1 = 0 ;
39893 int res1 = 0 ;
39894 void *argp2 = 0 ;
39895 int res2 = 0 ;
39896 PyObject * obj0 = 0 ;
39897 PyObject * obj1 = 0 ;
39898 char * kwnames[] = {
39899 (char *) "self",(char *) "item", NULL
39900 };
39901
39902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39904 if (!SWIG_IsOK(res1)) {
39905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39906 }
39907 arg1 = reinterpret_cast< wxMenu * >(argp1);
39908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39909 if (!SWIG_IsOK(res2)) {
39910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39911 }
39912 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39913 {
39914 PyThreadState* __tstate = wxPyBeginAllowThreads();
39915 result = (bool)(arg1)->Destroy(arg2);
39916 wxPyEndAllowThreads(__tstate);
39917 if (PyErr_Occurred()) SWIG_fail;
39918 }
39919 {
39920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39921 }
39922 return resultobj;
39923 fail:
39924 return NULL;
39925 }
39926
39927
39928 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39929 PyObject *resultobj = 0;
39930 wxMenu *arg1 = (wxMenu *) 0 ;
39931 size_t result;
39932 void *argp1 = 0 ;
39933 int res1 = 0 ;
39934 PyObject *swig_obj[1] ;
39935
39936 if (!args) SWIG_fail;
39937 swig_obj[0] = args;
39938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39939 if (!SWIG_IsOK(res1)) {
39940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39941 }
39942 arg1 = reinterpret_cast< wxMenu * >(argp1);
39943 {
39944 PyThreadState* __tstate = wxPyBeginAllowThreads();
39945 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39946 wxPyEndAllowThreads(__tstate);
39947 if (PyErr_Occurred()) SWIG_fail;
39948 }
39949 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39950 return resultobj;
39951 fail:
39952 return NULL;
39953 }
39954
39955
39956 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39957 PyObject *resultobj = 0;
39958 wxMenu *arg1 = (wxMenu *) 0 ;
39959 PyObject *result = 0 ;
39960 void *argp1 = 0 ;
39961 int res1 = 0 ;
39962 PyObject *swig_obj[1] ;
39963
39964 if (!args) SWIG_fail;
39965 swig_obj[0] = args;
39966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39967 if (!SWIG_IsOK(res1)) {
39968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39969 }
39970 arg1 = reinterpret_cast< wxMenu * >(argp1);
39971 {
39972 PyThreadState* __tstate = wxPyBeginAllowThreads();
39973 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 resultobj = result;
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39985 PyObject *resultobj = 0;
39986 wxMenu *arg1 = (wxMenu *) 0 ;
39987 wxString *arg2 = 0 ;
39988 int result;
39989 void *argp1 = 0 ;
39990 int res1 = 0 ;
39991 bool temp2 = false ;
39992 PyObject * obj0 = 0 ;
39993 PyObject * obj1 = 0 ;
39994 char * kwnames[] = {
39995 (char *) "self",(char *) "item", NULL
39996 };
39997
39998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40000 if (!SWIG_IsOK(res1)) {
40001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40002 }
40003 arg1 = reinterpret_cast< wxMenu * >(argp1);
40004 {
40005 arg2 = wxString_in_helper(obj1);
40006 if (arg2 == NULL) SWIG_fail;
40007 temp2 = true;
40008 }
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40012 wxPyEndAllowThreads(__tstate);
40013 if (PyErr_Occurred()) SWIG_fail;
40014 }
40015 resultobj = SWIG_From_int(static_cast< int >(result));
40016 {
40017 if (temp2)
40018 delete arg2;
40019 }
40020 return resultobj;
40021 fail:
40022 {
40023 if (temp2)
40024 delete arg2;
40025 }
40026 return NULL;
40027 }
40028
40029
40030 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40031 PyObject *resultobj = 0;
40032 wxMenu *arg1 = (wxMenu *) 0 ;
40033 int arg2 ;
40034 wxMenuItem *result = 0 ;
40035 void *argp1 = 0 ;
40036 int res1 = 0 ;
40037 int val2 ;
40038 int ecode2 = 0 ;
40039 PyObject * obj0 = 0 ;
40040 PyObject * obj1 = 0 ;
40041 char * kwnames[] = {
40042 (char *) "self",(char *) "id", NULL
40043 };
40044
40045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40047 if (!SWIG_IsOK(res1)) {
40048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40049 }
40050 arg1 = reinterpret_cast< wxMenu * >(argp1);
40051 ecode2 = SWIG_AsVal_int(obj1, &val2);
40052 if (!SWIG_IsOK(ecode2)) {
40053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40054 }
40055 arg2 = static_cast< int >(val2);
40056 {
40057 PyThreadState* __tstate = wxPyBeginAllowThreads();
40058 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40059 wxPyEndAllowThreads(__tstate);
40060 if (PyErr_Occurred()) SWIG_fail;
40061 }
40062 {
40063 resultobj = wxPyMake_wxObject(result, (bool)0);
40064 }
40065 return resultobj;
40066 fail:
40067 return NULL;
40068 }
40069
40070
40071 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40072 PyObject *resultobj = 0;
40073 wxMenu *arg1 = (wxMenu *) 0 ;
40074 size_t arg2 ;
40075 wxMenuItem *result = 0 ;
40076 void *argp1 = 0 ;
40077 int res1 = 0 ;
40078 size_t val2 ;
40079 int ecode2 = 0 ;
40080 PyObject * obj0 = 0 ;
40081 PyObject * obj1 = 0 ;
40082 char * kwnames[] = {
40083 (char *) "self",(char *) "position", NULL
40084 };
40085
40086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40088 if (!SWIG_IsOK(res1)) {
40089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40090 }
40091 arg1 = reinterpret_cast< wxMenu * >(argp1);
40092 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40093 if (!SWIG_IsOK(ecode2)) {
40094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40095 }
40096 arg2 = static_cast< size_t >(val2);
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = wxPyMake_wxObject(result, (bool)0);
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj = 0;
40114 wxMenu *arg1 = (wxMenu *) 0 ;
40115 int arg2 ;
40116 bool arg3 ;
40117 void *argp1 = 0 ;
40118 int res1 = 0 ;
40119 int val2 ;
40120 int ecode2 = 0 ;
40121 bool val3 ;
40122 int ecode3 = 0 ;
40123 PyObject * obj0 = 0 ;
40124 PyObject * obj1 = 0 ;
40125 PyObject * obj2 = 0 ;
40126 char * kwnames[] = {
40127 (char *) "self",(char *) "id",(char *) "enable", NULL
40128 };
40129
40130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40132 if (!SWIG_IsOK(res1)) {
40133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40134 }
40135 arg1 = reinterpret_cast< wxMenu * >(argp1);
40136 ecode2 = SWIG_AsVal_int(obj1, &val2);
40137 if (!SWIG_IsOK(ecode2)) {
40138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40139 }
40140 arg2 = static_cast< int >(val2);
40141 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40142 if (!SWIG_IsOK(ecode3)) {
40143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40144 }
40145 arg3 = static_cast< bool >(val3);
40146 {
40147 PyThreadState* __tstate = wxPyBeginAllowThreads();
40148 (arg1)->Enable(arg2,arg3);
40149 wxPyEndAllowThreads(__tstate);
40150 if (PyErr_Occurred()) SWIG_fail;
40151 }
40152 resultobj = SWIG_Py_Void();
40153 return resultobj;
40154 fail:
40155 return NULL;
40156 }
40157
40158
40159 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40160 PyObject *resultobj = 0;
40161 wxMenu *arg1 = (wxMenu *) 0 ;
40162 int arg2 ;
40163 bool result;
40164 void *argp1 = 0 ;
40165 int res1 = 0 ;
40166 int val2 ;
40167 int ecode2 = 0 ;
40168 PyObject * obj0 = 0 ;
40169 PyObject * obj1 = 0 ;
40170 char * kwnames[] = {
40171 (char *) "self",(char *) "id", NULL
40172 };
40173
40174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40176 if (!SWIG_IsOK(res1)) {
40177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40178 }
40179 arg1 = reinterpret_cast< wxMenu * >(argp1);
40180 ecode2 = SWIG_AsVal_int(obj1, &val2);
40181 if (!SWIG_IsOK(ecode2)) {
40182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40183 }
40184 arg2 = static_cast< int >(val2);
40185 {
40186 PyThreadState* __tstate = wxPyBeginAllowThreads();
40187 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 {
40192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40193 }
40194 return resultobj;
40195 fail:
40196 return NULL;
40197 }
40198
40199
40200 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40201 PyObject *resultobj = 0;
40202 wxMenu *arg1 = (wxMenu *) 0 ;
40203 int arg2 ;
40204 bool arg3 ;
40205 void *argp1 = 0 ;
40206 int res1 = 0 ;
40207 int val2 ;
40208 int ecode2 = 0 ;
40209 bool val3 ;
40210 int ecode3 = 0 ;
40211 PyObject * obj0 = 0 ;
40212 PyObject * obj1 = 0 ;
40213 PyObject * obj2 = 0 ;
40214 char * kwnames[] = {
40215 (char *) "self",(char *) "id",(char *) "check", NULL
40216 };
40217
40218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40220 if (!SWIG_IsOK(res1)) {
40221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40222 }
40223 arg1 = reinterpret_cast< wxMenu * >(argp1);
40224 ecode2 = SWIG_AsVal_int(obj1, &val2);
40225 if (!SWIG_IsOK(ecode2)) {
40226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40227 }
40228 arg2 = static_cast< int >(val2);
40229 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40230 if (!SWIG_IsOK(ecode3)) {
40231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40232 }
40233 arg3 = static_cast< bool >(val3);
40234 {
40235 PyThreadState* __tstate = wxPyBeginAllowThreads();
40236 (arg1)->Check(arg2,arg3);
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 resultobj = SWIG_Py_Void();
40241 return resultobj;
40242 fail:
40243 return NULL;
40244 }
40245
40246
40247 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj = 0;
40249 wxMenu *arg1 = (wxMenu *) 0 ;
40250 int arg2 ;
40251 bool result;
40252 void *argp1 = 0 ;
40253 int res1 = 0 ;
40254 int val2 ;
40255 int ecode2 = 0 ;
40256 PyObject * obj0 = 0 ;
40257 PyObject * obj1 = 0 ;
40258 char * kwnames[] = {
40259 (char *) "self",(char *) "id", NULL
40260 };
40261
40262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40264 if (!SWIG_IsOK(res1)) {
40265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40266 }
40267 arg1 = reinterpret_cast< wxMenu * >(argp1);
40268 ecode2 = SWIG_AsVal_int(obj1, &val2);
40269 if (!SWIG_IsOK(ecode2)) {
40270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40271 }
40272 arg2 = static_cast< int >(val2);
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40276 wxPyEndAllowThreads(__tstate);
40277 if (PyErr_Occurred()) SWIG_fail;
40278 }
40279 {
40280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40281 }
40282 return resultobj;
40283 fail:
40284 return NULL;
40285 }
40286
40287
40288 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40289 PyObject *resultobj = 0;
40290 wxMenu *arg1 = (wxMenu *) 0 ;
40291 int arg2 ;
40292 wxString *arg3 = 0 ;
40293 void *argp1 = 0 ;
40294 int res1 = 0 ;
40295 int val2 ;
40296 int ecode2 = 0 ;
40297 bool temp3 = false ;
40298 PyObject * obj0 = 0 ;
40299 PyObject * obj1 = 0 ;
40300 PyObject * obj2 = 0 ;
40301 char * kwnames[] = {
40302 (char *) "self",(char *) "id",(char *) "label", NULL
40303 };
40304
40305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40307 if (!SWIG_IsOK(res1)) {
40308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40309 }
40310 arg1 = reinterpret_cast< wxMenu * >(argp1);
40311 ecode2 = SWIG_AsVal_int(obj1, &val2);
40312 if (!SWIG_IsOK(ecode2)) {
40313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40314 }
40315 arg2 = static_cast< int >(val2);
40316 {
40317 arg3 = wxString_in_helper(obj2);
40318 if (arg3 == NULL) SWIG_fail;
40319 temp3 = true;
40320 }
40321 {
40322 PyThreadState* __tstate = wxPyBeginAllowThreads();
40323 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40324 wxPyEndAllowThreads(__tstate);
40325 if (PyErr_Occurred()) SWIG_fail;
40326 }
40327 resultobj = SWIG_Py_Void();
40328 {
40329 if (temp3)
40330 delete arg3;
40331 }
40332 return resultobj;
40333 fail:
40334 {
40335 if (temp3)
40336 delete arg3;
40337 }
40338 return NULL;
40339 }
40340
40341
40342 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40343 PyObject *resultobj = 0;
40344 wxMenu *arg1 = (wxMenu *) 0 ;
40345 int arg2 ;
40346 wxString result;
40347 void *argp1 = 0 ;
40348 int res1 = 0 ;
40349 int val2 ;
40350 int ecode2 = 0 ;
40351 PyObject * obj0 = 0 ;
40352 PyObject * obj1 = 0 ;
40353 char * kwnames[] = {
40354 (char *) "self",(char *) "id", NULL
40355 };
40356
40357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40359 if (!SWIG_IsOK(res1)) {
40360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40361 }
40362 arg1 = reinterpret_cast< wxMenu * >(argp1);
40363 ecode2 = SWIG_AsVal_int(obj1, &val2);
40364 if (!SWIG_IsOK(ecode2)) {
40365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40366 }
40367 arg2 = static_cast< int >(val2);
40368 {
40369 PyThreadState* __tstate = wxPyBeginAllowThreads();
40370 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40371 wxPyEndAllowThreads(__tstate);
40372 if (PyErr_Occurred()) SWIG_fail;
40373 }
40374 {
40375 #if wxUSE_UNICODE
40376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40377 #else
40378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40379 #endif
40380 }
40381 return resultobj;
40382 fail:
40383 return NULL;
40384 }
40385
40386
40387 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40388 PyObject *resultobj = 0;
40389 wxMenu *arg1 = (wxMenu *) 0 ;
40390 int arg2 ;
40391 wxString *arg3 = 0 ;
40392 void *argp1 = 0 ;
40393 int res1 = 0 ;
40394 int val2 ;
40395 int ecode2 = 0 ;
40396 bool temp3 = false ;
40397 PyObject * obj0 = 0 ;
40398 PyObject * obj1 = 0 ;
40399 PyObject * obj2 = 0 ;
40400 char * kwnames[] = {
40401 (char *) "self",(char *) "id",(char *) "helpString", NULL
40402 };
40403
40404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40406 if (!SWIG_IsOK(res1)) {
40407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40408 }
40409 arg1 = reinterpret_cast< wxMenu * >(argp1);
40410 ecode2 = SWIG_AsVal_int(obj1, &val2);
40411 if (!SWIG_IsOK(ecode2)) {
40412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40413 }
40414 arg2 = static_cast< int >(val2);
40415 {
40416 arg3 = wxString_in_helper(obj2);
40417 if (arg3 == NULL) SWIG_fail;
40418 temp3 = true;
40419 }
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 resultobj = SWIG_Py_Void();
40427 {
40428 if (temp3)
40429 delete arg3;
40430 }
40431 return resultobj;
40432 fail:
40433 {
40434 if (temp3)
40435 delete arg3;
40436 }
40437 return NULL;
40438 }
40439
40440
40441 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40442 PyObject *resultobj = 0;
40443 wxMenu *arg1 = (wxMenu *) 0 ;
40444 int arg2 ;
40445 wxString result;
40446 void *argp1 = 0 ;
40447 int res1 = 0 ;
40448 int val2 ;
40449 int ecode2 = 0 ;
40450 PyObject * obj0 = 0 ;
40451 PyObject * obj1 = 0 ;
40452 char * kwnames[] = {
40453 (char *) "self",(char *) "id", NULL
40454 };
40455
40456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40458 if (!SWIG_IsOK(res1)) {
40459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40460 }
40461 arg1 = reinterpret_cast< wxMenu * >(argp1);
40462 ecode2 = SWIG_AsVal_int(obj1, &val2);
40463 if (!SWIG_IsOK(ecode2)) {
40464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40465 }
40466 arg2 = static_cast< int >(val2);
40467 {
40468 PyThreadState* __tstate = wxPyBeginAllowThreads();
40469 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40470 wxPyEndAllowThreads(__tstate);
40471 if (PyErr_Occurred()) SWIG_fail;
40472 }
40473 {
40474 #if wxUSE_UNICODE
40475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40476 #else
40477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40478 #endif
40479 }
40480 return resultobj;
40481 fail:
40482 return NULL;
40483 }
40484
40485
40486 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40487 PyObject *resultobj = 0;
40488 wxMenu *arg1 = (wxMenu *) 0 ;
40489 wxString *arg2 = 0 ;
40490 void *argp1 = 0 ;
40491 int res1 = 0 ;
40492 bool temp2 = false ;
40493 PyObject * obj0 = 0 ;
40494 PyObject * obj1 = 0 ;
40495 char * kwnames[] = {
40496 (char *) "self",(char *) "title", NULL
40497 };
40498
40499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40501 if (!SWIG_IsOK(res1)) {
40502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40503 }
40504 arg1 = reinterpret_cast< wxMenu * >(argp1);
40505 {
40506 arg2 = wxString_in_helper(obj1);
40507 if (arg2 == NULL) SWIG_fail;
40508 temp2 = true;
40509 }
40510 {
40511 PyThreadState* __tstate = wxPyBeginAllowThreads();
40512 (arg1)->SetTitle((wxString const &)*arg2);
40513 wxPyEndAllowThreads(__tstate);
40514 if (PyErr_Occurred()) SWIG_fail;
40515 }
40516 resultobj = SWIG_Py_Void();
40517 {
40518 if (temp2)
40519 delete arg2;
40520 }
40521 return resultobj;
40522 fail:
40523 {
40524 if (temp2)
40525 delete arg2;
40526 }
40527 return NULL;
40528 }
40529
40530
40531 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40532 PyObject *resultobj = 0;
40533 wxMenu *arg1 = (wxMenu *) 0 ;
40534 wxString result;
40535 void *argp1 = 0 ;
40536 int res1 = 0 ;
40537 PyObject *swig_obj[1] ;
40538
40539 if (!args) SWIG_fail;
40540 swig_obj[0] = args;
40541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40542 if (!SWIG_IsOK(res1)) {
40543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40544 }
40545 arg1 = reinterpret_cast< wxMenu * >(argp1);
40546 {
40547 PyThreadState* __tstate = wxPyBeginAllowThreads();
40548 result = ((wxMenu const *)arg1)->GetTitle();
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 {
40553 #if wxUSE_UNICODE
40554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40555 #else
40556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40557 #endif
40558 }
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj = 0;
40567 wxMenu *arg1 = (wxMenu *) 0 ;
40568 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40569 void *argp1 = 0 ;
40570 int res1 = 0 ;
40571 void *argp2 = 0 ;
40572 int res2 = 0 ;
40573 PyObject * obj0 = 0 ;
40574 PyObject * obj1 = 0 ;
40575 char * kwnames[] = {
40576 (char *) "self",(char *) "handler", NULL
40577 };
40578
40579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40581 if (!SWIG_IsOK(res1)) {
40582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40583 }
40584 arg1 = reinterpret_cast< wxMenu * >(argp1);
40585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40586 if (!SWIG_IsOK(res2)) {
40587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40588 }
40589 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40590 {
40591 PyThreadState* __tstate = wxPyBeginAllowThreads();
40592 (arg1)->SetEventHandler(arg2);
40593 wxPyEndAllowThreads(__tstate);
40594 if (PyErr_Occurred()) SWIG_fail;
40595 }
40596 resultobj = SWIG_Py_Void();
40597 return resultobj;
40598 fail:
40599 return NULL;
40600 }
40601
40602
40603 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40604 PyObject *resultobj = 0;
40605 wxMenu *arg1 = (wxMenu *) 0 ;
40606 wxEvtHandler *result = 0 ;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 PyObject *swig_obj[1] ;
40610
40611 if (!args) SWIG_fail;
40612 swig_obj[0] = args;
40613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40614 if (!SWIG_IsOK(res1)) {
40615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40616 }
40617 arg1 = reinterpret_cast< wxMenu * >(argp1);
40618 {
40619 PyThreadState* __tstate = wxPyBeginAllowThreads();
40620 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40621 wxPyEndAllowThreads(__tstate);
40622 if (PyErr_Occurred()) SWIG_fail;
40623 }
40624 {
40625 resultobj = wxPyMake_wxObject(result, 0);
40626 }
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40634 PyObject *resultobj = 0;
40635 wxMenu *arg1 = (wxMenu *) 0 ;
40636 wxWindow *arg2 = (wxWindow *) 0 ;
40637 void *argp1 = 0 ;
40638 int res1 = 0 ;
40639 void *argp2 = 0 ;
40640 int res2 = 0 ;
40641 PyObject * obj0 = 0 ;
40642 PyObject * obj1 = 0 ;
40643 char * kwnames[] = {
40644 (char *) "self",(char *) "win", NULL
40645 };
40646
40647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40649 if (!SWIG_IsOK(res1)) {
40650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40651 }
40652 arg1 = reinterpret_cast< wxMenu * >(argp1);
40653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40654 if (!SWIG_IsOK(res2)) {
40655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40656 }
40657 arg2 = reinterpret_cast< wxWindow * >(argp2);
40658 {
40659 PyThreadState* __tstate = wxPyBeginAllowThreads();
40660 (arg1)->SetInvokingWindow(arg2);
40661 wxPyEndAllowThreads(__tstate);
40662 if (PyErr_Occurred()) SWIG_fail;
40663 }
40664 resultobj = SWIG_Py_Void();
40665 return resultobj;
40666 fail:
40667 return NULL;
40668 }
40669
40670
40671 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40672 PyObject *resultobj = 0;
40673 wxMenu *arg1 = (wxMenu *) 0 ;
40674 wxWindow *result = 0 ;
40675 void *argp1 = 0 ;
40676 int res1 = 0 ;
40677 PyObject *swig_obj[1] ;
40678
40679 if (!args) SWIG_fail;
40680 swig_obj[0] = args;
40681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40682 if (!SWIG_IsOK(res1)) {
40683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40684 }
40685 arg1 = reinterpret_cast< wxMenu * >(argp1);
40686 {
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40689 wxPyEndAllowThreads(__tstate);
40690 if (PyErr_Occurred()) SWIG_fail;
40691 }
40692 {
40693 resultobj = wxPyMake_wxObject(result, 0);
40694 }
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40702 PyObject *resultobj = 0;
40703 wxMenu *arg1 = (wxMenu *) 0 ;
40704 long result;
40705 void *argp1 = 0 ;
40706 int res1 = 0 ;
40707 PyObject *swig_obj[1] ;
40708
40709 if (!args) SWIG_fail;
40710 swig_obj[0] = args;
40711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40712 if (!SWIG_IsOK(res1)) {
40713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40714 }
40715 arg1 = reinterpret_cast< wxMenu * >(argp1);
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 result = (long)((wxMenu const *)arg1)->GetStyle();
40719 wxPyEndAllowThreads(__tstate);
40720 if (PyErr_Occurred()) SWIG_fail;
40721 }
40722 resultobj = SWIG_From_long(static_cast< long >(result));
40723 return resultobj;
40724 fail:
40725 return NULL;
40726 }
40727
40728
40729 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40730 PyObject *resultobj = 0;
40731 wxMenu *arg1 = (wxMenu *) 0 ;
40732 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40733 void *argp1 = 0 ;
40734 int res1 = 0 ;
40735 void *argp2 = 0 ;
40736 int res2 = 0 ;
40737 PyObject * obj0 = 0 ;
40738 PyObject * obj1 = 0 ;
40739 char * kwnames[] = {
40740 (char *) "self",(char *) "source", NULL
40741 };
40742
40743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40745 if (!SWIG_IsOK(res1)) {
40746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40747 }
40748 arg1 = reinterpret_cast< wxMenu * >(argp1);
40749 if (obj1) {
40750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40751 if (!SWIG_IsOK(res2)) {
40752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40753 }
40754 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40755 }
40756 {
40757 PyThreadState* __tstate = wxPyBeginAllowThreads();
40758 (arg1)->UpdateUI(arg2);
40759 wxPyEndAllowThreads(__tstate);
40760 if (PyErr_Occurred()) SWIG_fail;
40761 }
40762 resultobj = SWIG_Py_Void();
40763 return resultobj;
40764 fail:
40765 return NULL;
40766 }
40767
40768
40769 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40770 PyObject *resultobj = 0;
40771 wxMenu *arg1 = (wxMenu *) 0 ;
40772 wxMenuBar *result = 0 ;
40773 void *argp1 = 0 ;
40774 int res1 = 0 ;
40775 PyObject *swig_obj[1] ;
40776
40777 if (!args) SWIG_fail;
40778 swig_obj[0] = args;
40779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40780 if (!SWIG_IsOK(res1)) {
40781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40782 }
40783 arg1 = reinterpret_cast< wxMenu * >(argp1);
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 {
40791 resultobj = wxPyMake_wxObject(result, (bool)0);
40792 }
40793 return resultobj;
40794 fail:
40795 return NULL;
40796 }
40797
40798
40799 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40800 PyObject *resultobj = 0;
40801 wxMenu *arg1 = (wxMenu *) 0 ;
40802 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40803 void *argp1 = 0 ;
40804 int res1 = 0 ;
40805 void *argp2 = 0 ;
40806 int res2 = 0 ;
40807 PyObject * obj0 = 0 ;
40808 PyObject * obj1 = 0 ;
40809 char * kwnames[] = {
40810 (char *) "self",(char *) "menubar", NULL
40811 };
40812
40813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40817 }
40818 arg1 = reinterpret_cast< wxMenu * >(argp1);
40819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40820 if (!SWIG_IsOK(res2)) {
40821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40822 }
40823 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40824 {
40825 PyThreadState* __tstate = wxPyBeginAllowThreads();
40826 (arg1)->Attach(arg2);
40827 wxPyEndAllowThreads(__tstate);
40828 if (PyErr_Occurred()) SWIG_fail;
40829 }
40830 resultobj = SWIG_Py_Void();
40831 return resultobj;
40832 fail:
40833 return NULL;
40834 }
40835
40836
40837 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40838 PyObject *resultobj = 0;
40839 wxMenu *arg1 = (wxMenu *) 0 ;
40840 void *argp1 = 0 ;
40841 int res1 = 0 ;
40842 PyObject *swig_obj[1] ;
40843
40844 if (!args) SWIG_fail;
40845 swig_obj[0] = args;
40846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40847 if (!SWIG_IsOK(res1)) {
40848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40849 }
40850 arg1 = reinterpret_cast< wxMenu * >(argp1);
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 (arg1)->Detach();
40854 wxPyEndAllowThreads(__tstate);
40855 if (PyErr_Occurred()) SWIG_fail;
40856 }
40857 resultobj = SWIG_Py_Void();
40858 return resultobj;
40859 fail:
40860 return NULL;
40861 }
40862
40863
40864 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40865 PyObject *resultobj = 0;
40866 wxMenu *arg1 = (wxMenu *) 0 ;
40867 bool result;
40868 void *argp1 = 0 ;
40869 int res1 = 0 ;
40870 PyObject *swig_obj[1] ;
40871
40872 if (!args) SWIG_fail;
40873 swig_obj[0] = args;
40874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40875 if (!SWIG_IsOK(res1)) {
40876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40877 }
40878 arg1 = reinterpret_cast< wxMenu * >(argp1);
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (bool)((wxMenu const *)arg1)->IsAttached();
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40887 }
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40895 PyObject *resultobj = 0;
40896 wxMenu *arg1 = (wxMenu *) 0 ;
40897 wxMenu *arg2 = (wxMenu *) 0 ;
40898 void *argp1 = 0 ;
40899 int res1 = 0 ;
40900 void *argp2 = 0 ;
40901 int res2 = 0 ;
40902 PyObject * obj0 = 0 ;
40903 PyObject * obj1 = 0 ;
40904 char * kwnames[] = {
40905 (char *) "self",(char *) "parent", NULL
40906 };
40907
40908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40910 if (!SWIG_IsOK(res1)) {
40911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40912 }
40913 arg1 = reinterpret_cast< wxMenu * >(argp1);
40914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40915 if (!SWIG_IsOK(res2)) {
40916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40917 }
40918 arg2 = reinterpret_cast< wxMenu * >(argp2);
40919 {
40920 PyThreadState* __tstate = wxPyBeginAllowThreads();
40921 (arg1)->SetParent(arg2);
40922 wxPyEndAllowThreads(__tstate);
40923 if (PyErr_Occurred()) SWIG_fail;
40924 }
40925 resultobj = SWIG_Py_Void();
40926 return resultobj;
40927 fail:
40928 return NULL;
40929 }
40930
40931
40932 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40933 PyObject *resultobj = 0;
40934 wxMenu *arg1 = (wxMenu *) 0 ;
40935 wxMenu *result = 0 ;
40936 void *argp1 = 0 ;
40937 int res1 = 0 ;
40938 PyObject *swig_obj[1] ;
40939
40940 if (!args) SWIG_fail;
40941 swig_obj[0] = args;
40942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40943 if (!SWIG_IsOK(res1)) {
40944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40945 }
40946 arg1 = reinterpret_cast< wxMenu * >(argp1);
40947 {
40948 PyThreadState* __tstate = wxPyBeginAllowThreads();
40949 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40950 wxPyEndAllowThreads(__tstate);
40951 if (PyErr_Occurred()) SWIG_fail;
40952 }
40953 {
40954 resultobj = wxPyMake_wxObject(result, 0);
40955 }
40956 return resultobj;
40957 fail:
40958 return NULL;
40959 }
40960
40961
40962 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40963 PyObject *obj;
40964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40965 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40966 return SWIG_Py_Void();
40967 }
40968
40969 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40970 return SWIG_Python_InitShadowInstance(args);
40971 }
40972
40973 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40974 PyObject *resultobj = 0;
40975 long arg1 = (long) 0 ;
40976 wxMenuBar *result = 0 ;
40977 long val1 ;
40978 int ecode1 = 0 ;
40979 PyObject * obj0 = 0 ;
40980 char * kwnames[] = {
40981 (char *) "style", NULL
40982 };
40983
40984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40985 if (obj0) {
40986 ecode1 = SWIG_AsVal_long(obj0, &val1);
40987 if (!SWIG_IsOK(ecode1)) {
40988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40989 }
40990 arg1 = static_cast< long >(val1);
40991 }
40992 {
40993 if (!wxPyCheckForApp()) SWIG_fail;
40994 PyThreadState* __tstate = wxPyBeginAllowThreads();
40995 result = (wxMenuBar *)new wxMenuBar(arg1);
40996 wxPyEndAllowThreads(__tstate);
40997 if (PyErr_Occurred()) SWIG_fail;
40998 }
40999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41000 return resultobj;
41001 fail:
41002 return NULL;
41003 }
41004
41005
41006 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41007 PyObject *resultobj = 0;
41008 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41009 wxMenu *arg2 = (wxMenu *) 0 ;
41010 wxString *arg3 = 0 ;
41011 bool result;
41012 void *argp1 = 0 ;
41013 int res1 = 0 ;
41014 void *argp2 = 0 ;
41015 int res2 = 0 ;
41016 bool temp3 = false ;
41017 PyObject * obj0 = 0 ;
41018 PyObject * obj1 = 0 ;
41019 PyObject * obj2 = 0 ;
41020 char * kwnames[] = {
41021 (char *) "self",(char *) "menu",(char *) "title", NULL
41022 };
41023
41024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41026 if (!SWIG_IsOK(res1)) {
41027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41028 }
41029 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41031 if (!SWIG_IsOK(res2)) {
41032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41033 }
41034 arg2 = reinterpret_cast< wxMenu * >(argp2);
41035 {
41036 arg3 = wxString_in_helper(obj2);
41037 if (arg3 == NULL) SWIG_fail;
41038 temp3 = true;
41039 }
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 {
41047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41048 }
41049 {
41050 if (temp3)
41051 delete arg3;
41052 }
41053 return resultobj;
41054 fail:
41055 {
41056 if (temp3)
41057 delete arg3;
41058 }
41059 return NULL;
41060 }
41061
41062
41063 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj = 0;
41065 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41066 size_t arg2 ;
41067 wxMenu *arg3 = (wxMenu *) 0 ;
41068 wxString *arg4 = 0 ;
41069 bool result;
41070 void *argp1 = 0 ;
41071 int res1 = 0 ;
41072 size_t val2 ;
41073 int ecode2 = 0 ;
41074 void *argp3 = 0 ;
41075 int res3 = 0 ;
41076 bool temp4 = false ;
41077 PyObject * obj0 = 0 ;
41078 PyObject * obj1 = 0 ;
41079 PyObject * obj2 = 0 ;
41080 PyObject * obj3 = 0 ;
41081 char * kwnames[] = {
41082 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41083 };
41084
41085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41087 if (!SWIG_IsOK(res1)) {
41088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41089 }
41090 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41091 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41092 if (!SWIG_IsOK(ecode2)) {
41093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41094 }
41095 arg2 = static_cast< size_t >(val2);
41096 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41097 if (!SWIG_IsOK(res3)) {
41098 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41099 }
41100 arg3 = reinterpret_cast< wxMenu * >(argp3);
41101 {
41102 arg4 = wxString_in_helper(obj3);
41103 if (arg4 == NULL) SWIG_fail;
41104 temp4 = true;
41105 }
41106 {
41107 PyThreadState* __tstate = wxPyBeginAllowThreads();
41108 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41109 wxPyEndAllowThreads(__tstate);
41110 if (PyErr_Occurred()) SWIG_fail;
41111 }
41112 {
41113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41114 }
41115 {
41116 if (temp4)
41117 delete arg4;
41118 }
41119 return resultobj;
41120 fail:
41121 {
41122 if (temp4)
41123 delete arg4;
41124 }
41125 return NULL;
41126 }
41127
41128
41129 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41130 PyObject *resultobj = 0;
41131 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41132 size_t result;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 PyObject *swig_obj[1] ;
41136
41137 if (!args) SWIG_fail;
41138 swig_obj[0] = args;
41139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41140 if (!SWIG_IsOK(res1)) {
41141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41142 }
41143 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41151 return resultobj;
41152 fail:
41153 return NULL;
41154 }
41155
41156
41157 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41158 PyObject *resultobj = 0;
41159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41160 size_t arg2 ;
41161 wxMenu *result = 0 ;
41162 void *argp1 = 0 ;
41163 int res1 = 0 ;
41164 size_t val2 ;
41165 int ecode2 = 0 ;
41166 PyObject * obj0 = 0 ;
41167 PyObject * obj1 = 0 ;
41168 char * kwnames[] = {
41169 (char *) "self",(char *) "pos", NULL
41170 };
41171
41172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41174 if (!SWIG_IsOK(res1)) {
41175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41176 }
41177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41178 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41179 if (!SWIG_IsOK(ecode2)) {
41180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41181 }
41182 arg2 = static_cast< size_t >(val2);
41183 {
41184 PyThreadState* __tstate = wxPyBeginAllowThreads();
41185 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41186 wxPyEndAllowThreads(__tstate);
41187 if (PyErr_Occurred()) SWIG_fail;
41188 }
41189 {
41190 resultobj = wxPyMake_wxObject(result, 0);
41191 }
41192 return resultobj;
41193 fail:
41194 return NULL;
41195 }
41196
41197
41198 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41199 PyObject *resultobj = 0;
41200 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41201 size_t arg2 ;
41202 wxMenu *arg3 = (wxMenu *) 0 ;
41203 wxString *arg4 = 0 ;
41204 wxMenu *result = 0 ;
41205 void *argp1 = 0 ;
41206 int res1 = 0 ;
41207 size_t val2 ;
41208 int ecode2 = 0 ;
41209 void *argp3 = 0 ;
41210 int res3 = 0 ;
41211 bool temp4 = false ;
41212 PyObject * obj0 = 0 ;
41213 PyObject * obj1 = 0 ;
41214 PyObject * obj2 = 0 ;
41215 PyObject * obj3 = 0 ;
41216 char * kwnames[] = {
41217 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41218 };
41219
41220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41222 if (!SWIG_IsOK(res1)) {
41223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41224 }
41225 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41226 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41227 if (!SWIG_IsOK(ecode2)) {
41228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41229 }
41230 arg2 = static_cast< size_t >(val2);
41231 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41232 if (!SWIG_IsOK(res3)) {
41233 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41234 }
41235 arg3 = reinterpret_cast< wxMenu * >(argp3);
41236 {
41237 arg4 = wxString_in_helper(obj3);
41238 if (arg4 == NULL) SWIG_fail;
41239 temp4 = true;
41240 }
41241 {
41242 PyThreadState* __tstate = wxPyBeginAllowThreads();
41243 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41244 wxPyEndAllowThreads(__tstate);
41245 if (PyErr_Occurred()) SWIG_fail;
41246 }
41247 {
41248 resultobj = wxPyMake_wxObject(result, 0);
41249 }
41250 {
41251 if (temp4)
41252 delete arg4;
41253 }
41254 return resultobj;
41255 fail:
41256 {
41257 if (temp4)
41258 delete arg4;
41259 }
41260 return NULL;
41261 }
41262
41263
41264 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj = 0;
41266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41267 size_t arg2 ;
41268 wxMenu *result = 0 ;
41269 void *argp1 = 0 ;
41270 int res1 = 0 ;
41271 size_t val2 ;
41272 int ecode2 = 0 ;
41273 PyObject * obj0 = 0 ;
41274 PyObject * obj1 = 0 ;
41275 char * kwnames[] = {
41276 (char *) "self",(char *) "pos", NULL
41277 };
41278
41279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41281 if (!SWIG_IsOK(res1)) {
41282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41283 }
41284 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41285 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41286 if (!SWIG_IsOK(ecode2)) {
41287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41288 }
41289 arg2 = static_cast< size_t >(val2);
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 result = (wxMenu *)(arg1)->Remove(arg2);
41293 wxPyEndAllowThreads(__tstate);
41294 if (PyErr_Occurred()) SWIG_fail;
41295 }
41296 {
41297 resultobj = wxPyMake_wxObject(result, 0);
41298 }
41299 return resultobj;
41300 fail:
41301 return NULL;
41302 }
41303
41304
41305 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41306 PyObject *resultobj = 0;
41307 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41308 size_t arg2 ;
41309 bool arg3 ;
41310 void *argp1 = 0 ;
41311 int res1 = 0 ;
41312 size_t val2 ;
41313 int ecode2 = 0 ;
41314 bool val3 ;
41315 int ecode3 = 0 ;
41316 PyObject * obj0 = 0 ;
41317 PyObject * obj1 = 0 ;
41318 PyObject * obj2 = 0 ;
41319 char * kwnames[] = {
41320 (char *) "self",(char *) "pos",(char *) "enable", NULL
41321 };
41322
41323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41325 if (!SWIG_IsOK(res1)) {
41326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41327 }
41328 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41329 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41330 if (!SWIG_IsOK(ecode2)) {
41331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41332 }
41333 arg2 = static_cast< size_t >(val2);
41334 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41335 if (!SWIG_IsOK(ecode3)) {
41336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41337 }
41338 arg3 = static_cast< bool >(val3);
41339 {
41340 PyThreadState* __tstate = wxPyBeginAllowThreads();
41341 (arg1)->EnableTop(arg2,arg3);
41342 wxPyEndAllowThreads(__tstate);
41343 if (PyErr_Occurred()) SWIG_fail;
41344 }
41345 resultobj = SWIG_Py_Void();
41346 return resultobj;
41347 fail:
41348 return NULL;
41349 }
41350
41351
41352 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41353 PyObject *resultobj = 0;
41354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41355 size_t arg2 ;
41356 bool result;
41357 void *argp1 = 0 ;
41358 int res1 = 0 ;
41359 size_t val2 ;
41360 int ecode2 = 0 ;
41361 PyObject * obj0 = 0 ;
41362 PyObject * obj1 = 0 ;
41363 char * kwnames[] = {
41364 (char *) "self",(char *) "pos", NULL
41365 };
41366
41367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41369 if (!SWIG_IsOK(res1)) {
41370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41371 }
41372 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41373 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41374 if (!SWIG_IsOK(ecode2)) {
41375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41376 }
41377 arg2 = static_cast< size_t >(val2);
41378 {
41379 PyThreadState* __tstate = wxPyBeginAllowThreads();
41380 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 {
41385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj = 0;
41395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41396 size_t arg2 ;
41397 wxString *arg3 = 0 ;
41398 void *argp1 = 0 ;
41399 int res1 = 0 ;
41400 size_t val2 ;
41401 int ecode2 = 0 ;
41402 bool temp3 = false ;
41403 PyObject * obj0 = 0 ;
41404 PyObject * obj1 = 0 ;
41405 PyObject * obj2 = 0 ;
41406 char * kwnames[] = {
41407 (char *) "self",(char *) "pos",(char *) "label", NULL
41408 };
41409
41410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41412 if (!SWIG_IsOK(res1)) {
41413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41414 }
41415 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41416 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41417 if (!SWIG_IsOK(ecode2)) {
41418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41419 }
41420 arg2 = static_cast< size_t >(val2);
41421 {
41422 arg3 = wxString_in_helper(obj2);
41423 if (arg3 == NULL) SWIG_fail;
41424 temp3 = true;
41425 }
41426 {
41427 PyThreadState* __tstate = wxPyBeginAllowThreads();
41428 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 resultobj = SWIG_Py_Void();
41433 {
41434 if (temp3)
41435 delete arg3;
41436 }
41437 return resultobj;
41438 fail:
41439 {
41440 if (temp3)
41441 delete arg3;
41442 }
41443 return NULL;
41444 }
41445
41446
41447 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41448 PyObject *resultobj = 0;
41449 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41450 size_t arg2 ;
41451 wxString result;
41452 void *argp1 = 0 ;
41453 int res1 = 0 ;
41454 size_t val2 ;
41455 int ecode2 = 0 ;
41456 PyObject * obj0 = 0 ;
41457 PyObject * obj1 = 0 ;
41458 char * kwnames[] = {
41459 (char *) "self",(char *) "pos", NULL
41460 };
41461
41462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41464 if (!SWIG_IsOK(res1)) {
41465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41466 }
41467 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41468 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41469 if (!SWIG_IsOK(ecode2)) {
41470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41471 }
41472 arg2 = static_cast< size_t >(val2);
41473 {
41474 PyThreadState* __tstate = wxPyBeginAllowThreads();
41475 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41476 wxPyEndAllowThreads(__tstate);
41477 if (PyErr_Occurred()) SWIG_fail;
41478 }
41479 {
41480 #if wxUSE_UNICODE
41481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41482 #else
41483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41484 #endif
41485 }
41486 return resultobj;
41487 fail:
41488 return NULL;
41489 }
41490
41491
41492 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41493 PyObject *resultobj = 0;
41494 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41495 wxString *arg2 = 0 ;
41496 wxString *arg3 = 0 ;
41497 int result;
41498 void *argp1 = 0 ;
41499 int res1 = 0 ;
41500 bool temp2 = false ;
41501 bool temp3 = false ;
41502 PyObject * obj0 = 0 ;
41503 PyObject * obj1 = 0 ;
41504 PyObject * obj2 = 0 ;
41505 char * kwnames[] = {
41506 (char *) "self",(char *) "menu",(char *) "item", NULL
41507 };
41508
41509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41511 if (!SWIG_IsOK(res1)) {
41512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41513 }
41514 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41515 {
41516 arg2 = wxString_in_helper(obj1);
41517 if (arg2 == NULL) SWIG_fail;
41518 temp2 = true;
41519 }
41520 {
41521 arg3 = wxString_in_helper(obj2);
41522 if (arg3 == NULL) SWIG_fail;
41523 temp3 = true;
41524 }
41525 {
41526 PyThreadState* __tstate = wxPyBeginAllowThreads();
41527 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41528 wxPyEndAllowThreads(__tstate);
41529 if (PyErr_Occurred()) SWIG_fail;
41530 }
41531 resultobj = SWIG_From_int(static_cast< int >(result));
41532 {
41533 if (temp2)
41534 delete arg2;
41535 }
41536 {
41537 if (temp3)
41538 delete arg3;
41539 }
41540 return resultobj;
41541 fail:
41542 {
41543 if (temp2)
41544 delete arg2;
41545 }
41546 {
41547 if (temp3)
41548 delete arg3;
41549 }
41550 return NULL;
41551 }
41552
41553
41554 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41555 PyObject *resultobj = 0;
41556 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41557 int arg2 ;
41558 wxMenuItem *result = 0 ;
41559 void *argp1 = 0 ;
41560 int res1 = 0 ;
41561 int val2 ;
41562 int ecode2 = 0 ;
41563 PyObject * obj0 = 0 ;
41564 PyObject * obj1 = 0 ;
41565 char * kwnames[] = {
41566 (char *) "self",(char *) "id", NULL
41567 };
41568
41569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41571 if (!SWIG_IsOK(res1)) {
41572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41573 }
41574 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41575 ecode2 = SWIG_AsVal_int(obj1, &val2);
41576 if (!SWIG_IsOK(ecode2)) {
41577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41578 }
41579 arg2 = static_cast< int >(val2);
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 {
41587 resultobj = wxPyMake_wxObject(result, (bool)0);
41588 }
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj = 0;
41597 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41598 wxString *arg2 = 0 ;
41599 int result;
41600 void *argp1 = 0 ;
41601 int res1 = 0 ;
41602 bool temp2 = false ;
41603 PyObject * obj0 = 0 ;
41604 PyObject * obj1 = 0 ;
41605 char * kwnames[] = {
41606 (char *) "self",(char *) "title", NULL
41607 };
41608
41609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41611 if (!SWIG_IsOK(res1)) {
41612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41613 }
41614 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41615 {
41616 arg2 = wxString_in_helper(obj1);
41617 if (arg2 == NULL) SWIG_fail;
41618 temp2 = true;
41619 }
41620 {
41621 PyThreadState* __tstate = wxPyBeginAllowThreads();
41622 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41623 wxPyEndAllowThreads(__tstate);
41624 if (PyErr_Occurred()) SWIG_fail;
41625 }
41626 resultobj = SWIG_From_int(static_cast< int >(result));
41627 {
41628 if (temp2)
41629 delete arg2;
41630 }
41631 return resultobj;
41632 fail:
41633 {
41634 if (temp2)
41635 delete arg2;
41636 }
41637 return NULL;
41638 }
41639
41640
41641 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41642 PyObject *resultobj = 0;
41643 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41644 int arg2 ;
41645 bool arg3 ;
41646 void *argp1 = 0 ;
41647 int res1 = 0 ;
41648 int val2 ;
41649 int ecode2 = 0 ;
41650 bool val3 ;
41651 int ecode3 = 0 ;
41652 PyObject * obj0 = 0 ;
41653 PyObject * obj1 = 0 ;
41654 PyObject * obj2 = 0 ;
41655 char * kwnames[] = {
41656 (char *) "self",(char *) "id",(char *) "enable", NULL
41657 };
41658
41659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41661 if (!SWIG_IsOK(res1)) {
41662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41663 }
41664 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41665 ecode2 = SWIG_AsVal_int(obj1, &val2);
41666 if (!SWIG_IsOK(ecode2)) {
41667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41668 }
41669 arg2 = static_cast< int >(val2);
41670 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41671 if (!SWIG_IsOK(ecode3)) {
41672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41673 }
41674 arg3 = static_cast< bool >(val3);
41675 {
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 (arg1)->Enable(arg2,arg3);
41678 wxPyEndAllowThreads(__tstate);
41679 if (PyErr_Occurred()) SWIG_fail;
41680 }
41681 resultobj = SWIG_Py_Void();
41682 return resultobj;
41683 fail:
41684 return NULL;
41685 }
41686
41687
41688 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41689 PyObject *resultobj = 0;
41690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41691 int arg2 ;
41692 bool arg3 ;
41693 void *argp1 = 0 ;
41694 int res1 = 0 ;
41695 int val2 ;
41696 int ecode2 = 0 ;
41697 bool val3 ;
41698 int ecode3 = 0 ;
41699 PyObject * obj0 = 0 ;
41700 PyObject * obj1 = 0 ;
41701 PyObject * obj2 = 0 ;
41702 char * kwnames[] = {
41703 (char *) "self",(char *) "id",(char *) "check", NULL
41704 };
41705
41706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41708 if (!SWIG_IsOK(res1)) {
41709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41710 }
41711 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41712 ecode2 = SWIG_AsVal_int(obj1, &val2);
41713 if (!SWIG_IsOK(ecode2)) {
41714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41715 }
41716 arg2 = static_cast< int >(val2);
41717 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41718 if (!SWIG_IsOK(ecode3)) {
41719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41720 }
41721 arg3 = static_cast< bool >(val3);
41722 {
41723 PyThreadState* __tstate = wxPyBeginAllowThreads();
41724 (arg1)->Check(arg2,arg3);
41725 wxPyEndAllowThreads(__tstate);
41726 if (PyErr_Occurred()) SWIG_fail;
41727 }
41728 resultobj = SWIG_Py_Void();
41729 return resultobj;
41730 fail:
41731 return NULL;
41732 }
41733
41734
41735 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41736 PyObject *resultobj = 0;
41737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41738 int arg2 ;
41739 bool result;
41740 void *argp1 = 0 ;
41741 int res1 = 0 ;
41742 int val2 ;
41743 int ecode2 = 0 ;
41744 PyObject * obj0 = 0 ;
41745 PyObject * obj1 = 0 ;
41746 char * kwnames[] = {
41747 (char *) "self",(char *) "id", NULL
41748 };
41749
41750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41752 if (!SWIG_IsOK(res1)) {
41753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41754 }
41755 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41756 ecode2 = SWIG_AsVal_int(obj1, &val2);
41757 if (!SWIG_IsOK(ecode2)) {
41758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41759 }
41760 arg2 = static_cast< int >(val2);
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41764 wxPyEndAllowThreads(__tstate);
41765 if (PyErr_Occurred()) SWIG_fail;
41766 }
41767 {
41768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41769 }
41770 return resultobj;
41771 fail:
41772 return NULL;
41773 }
41774
41775
41776 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41777 PyObject *resultobj = 0;
41778 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41779 int arg2 ;
41780 bool result;
41781 void *argp1 = 0 ;
41782 int res1 = 0 ;
41783 int val2 ;
41784 int ecode2 = 0 ;
41785 PyObject * obj0 = 0 ;
41786 PyObject * obj1 = 0 ;
41787 char * kwnames[] = {
41788 (char *) "self",(char *) "id", NULL
41789 };
41790
41791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41793 if (!SWIG_IsOK(res1)) {
41794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41795 }
41796 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41797 ecode2 = SWIG_AsVal_int(obj1, &val2);
41798 if (!SWIG_IsOK(ecode2)) {
41799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41800 }
41801 arg2 = static_cast< int >(val2);
41802 {
41803 PyThreadState* __tstate = wxPyBeginAllowThreads();
41804 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41805 wxPyEndAllowThreads(__tstate);
41806 if (PyErr_Occurred()) SWIG_fail;
41807 }
41808 {
41809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41810 }
41811 return resultobj;
41812 fail:
41813 return NULL;
41814 }
41815
41816
41817 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41818 PyObject *resultobj = 0;
41819 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41820 int arg2 ;
41821 wxString *arg3 = 0 ;
41822 void *argp1 = 0 ;
41823 int res1 = 0 ;
41824 int val2 ;
41825 int ecode2 = 0 ;
41826 bool temp3 = false ;
41827 PyObject * obj0 = 0 ;
41828 PyObject * obj1 = 0 ;
41829 PyObject * obj2 = 0 ;
41830 char * kwnames[] = {
41831 (char *) "self",(char *) "id",(char *) "label", NULL
41832 };
41833
41834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41836 if (!SWIG_IsOK(res1)) {
41837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41838 }
41839 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41840 ecode2 = SWIG_AsVal_int(obj1, &val2);
41841 if (!SWIG_IsOK(ecode2)) {
41842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41843 }
41844 arg2 = static_cast< int >(val2);
41845 {
41846 arg3 = wxString_in_helper(obj2);
41847 if (arg3 == NULL) SWIG_fail;
41848 temp3 = true;
41849 }
41850 {
41851 PyThreadState* __tstate = wxPyBeginAllowThreads();
41852 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41853 wxPyEndAllowThreads(__tstate);
41854 if (PyErr_Occurred()) SWIG_fail;
41855 }
41856 resultobj = SWIG_Py_Void();
41857 {
41858 if (temp3)
41859 delete arg3;
41860 }
41861 return resultobj;
41862 fail:
41863 {
41864 if (temp3)
41865 delete arg3;
41866 }
41867 return NULL;
41868 }
41869
41870
41871 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41872 PyObject *resultobj = 0;
41873 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41874 int arg2 ;
41875 wxString result;
41876 void *argp1 = 0 ;
41877 int res1 = 0 ;
41878 int val2 ;
41879 int ecode2 = 0 ;
41880 PyObject * obj0 = 0 ;
41881 PyObject * obj1 = 0 ;
41882 char * kwnames[] = {
41883 (char *) "self",(char *) "id", NULL
41884 };
41885
41886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41888 if (!SWIG_IsOK(res1)) {
41889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41890 }
41891 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41892 ecode2 = SWIG_AsVal_int(obj1, &val2);
41893 if (!SWIG_IsOK(ecode2)) {
41894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41895 }
41896 arg2 = static_cast< int >(val2);
41897 {
41898 PyThreadState* __tstate = wxPyBeginAllowThreads();
41899 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 {
41904 #if wxUSE_UNICODE
41905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41906 #else
41907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41908 #endif
41909 }
41910 return resultobj;
41911 fail:
41912 return NULL;
41913 }
41914
41915
41916 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41917 PyObject *resultobj = 0;
41918 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41919 int arg2 ;
41920 wxString *arg3 = 0 ;
41921 void *argp1 = 0 ;
41922 int res1 = 0 ;
41923 int val2 ;
41924 int ecode2 = 0 ;
41925 bool temp3 = false ;
41926 PyObject * obj0 = 0 ;
41927 PyObject * obj1 = 0 ;
41928 PyObject * obj2 = 0 ;
41929 char * kwnames[] = {
41930 (char *) "self",(char *) "id",(char *) "helpString", NULL
41931 };
41932
41933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41935 if (!SWIG_IsOK(res1)) {
41936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41937 }
41938 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41939 ecode2 = SWIG_AsVal_int(obj1, &val2);
41940 if (!SWIG_IsOK(ecode2)) {
41941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41942 }
41943 arg2 = static_cast< int >(val2);
41944 {
41945 arg3 = wxString_in_helper(obj2);
41946 if (arg3 == NULL) SWIG_fail;
41947 temp3 = true;
41948 }
41949 {
41950 PyThreadState* __tstate = wxPyBeginAllowThreads();
41951 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41952 wxPyEndAllowThreads(__tstate);
41953 if (PyErr_Occurred()) SWIG_fail;
41954 }
41955 resultobj = SWIG_Py_Void();
41956 {
41957 if (temp3)
41958 delete arg3;
41959 }
41960 return resultobj;
41961 fail:
41962 {
41963 if (temp3)
41964 delete arg3;
41965 }
41966 return NULL;
41967 }
41968
41969
41970 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41971 PyObject *resultobj = 0;
41972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41973 int arg2 ;
41974 wxString result;
41975 void *argp1 = 0 ;
41976 int res1 = 0 ;
41977 int val2 ;
41978 int ecode2 = 0 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 char * kwnames[] = {
41982 (char *) "self",(char *) "id", NULL
41983 };
41984
41985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41987 if (!SWIG_IsOK(res1)) {
41988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41989 }
41990 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41991 ecode2 = SWIG_AsVal_int(obj1, &val2);
41992 if (!SWIG_IsOK(ecode2)) {
41993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41994 }
41995 arg2 = static_cast< int >(val2);
41996 {
41997 PyThreadState* __tstate = wxPyBeginAllowThreads();
41998 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41999 wxPyEndAllowThreads(__tstate);
42000 if (PyErr_Occurred()) SWIG_fail;
42001 }
42002 {
42003 #if wxUSE_UNICODE
42004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42005 #else
42006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42007 #endif
42008 }
42009 return resultobj;
42010 fail:
42011 return NULL;
42012 }
42013
42014
42015 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42016 PyObject *resultobj = 0;
42017 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42018 wxFrame *result = 0 ;
42019 void *argp1 = 0 ;
42020 int res1 = 0 ;
42021 PyObject *swig_obj[1] ;
42022
42023 if (!args) SWIG_fail;
42024 swig_obj[0] = args;
42025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42026 if (!SWIG_IsOK(res1)) {
42027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42028 }
42029 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42030 {
42031 PyThreadState* __tstate = wxPyBeginAllowThreads();
42032 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42033 wxPyEndAllowThreads(__tstate);
42034 if (PyErr_Occurred()) SWIG_fail;
42035 }
42036 {
42037 resultobj = wxPyMake_wxObject(result, (bool)0);
42038 }
42039 return resultobj;
42040 fail:
42041 return NULL;
42042 }
42043
42044
42045 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42046 PyObject *resultobj = 0;
42047 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42048 bool result;
42049 void *argp1 = 0 ;
42050 int res1 = 0 ;
42051 PyObject *swig_obj[1] ;
42052
42053 if (!args) SWIG_fail;
42054 swig_obj[0] = args;
42055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42056 if (!SWIG_IsOK(res1)) {
42057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42058 }
42059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42060 {
42061 PyThreadState* __tstate = wxPyBeginAllowThreads();
42062 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42063 wxPyEndAllowThreads(__tstate);
42064 if (PyErr_Occurred()) SWIG_fail;
42065 }
42066 {
42067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42068 }
42069 return resultobj;
42070 fail:
42071 return NULL;
42072 }
42073
42074
42075 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42076 PyObject *resultobj = 0;
42077 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42078 wxFrame *arg2 = (wxFrame *) 0 ;
42079 void *argp1 = 0 ;
42080 int res1 = 0 ;
42081 void *argp2 = 0 ;
42082 int res2 = 0 ;
42083 PyObject * obj0 = 0 ;
42084 PyObject * obj1 = 0 ;
42085 char * kwnames[] = {
42086 (char *) "self",(char *) "frame", NULL
42087 };
42088
42089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42091 if (!SWIG_IsOK(res1)) {
42092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42093 }
42094 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42095 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42096 if (!SWIG_IsOK(res2)) {
42097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42098 }
42099 arg2 = reinterpret_cast< wxFrame * >(argp2);
42100 {
42101 PyThreadState* __tstate = wxPyBeginAllowThreads();
42102 (arg1)->Attach(arg2);
42103 wxPyEndAllowThreads(__tstate);
42104 if (PyErr_Occurred()) SWIG_fail;
42105 }
42106 resultobj = SWIG_Py_Void();
42107 return resultobj;
42108 fail:
42109 return NULL;
42110 }
42111
42112
42113 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42114 PyObject *resultobj = 0;
42115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42116 void *argp1 = 0 ;
42117 int res1 = 0 ;
42118 PyObject *swig_obj[1] ;
42119
42120 if (!args) SWIG_fail;
42121 swig_obj[0] = args;
42122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42123 if (!SWIG_IsOK(res1)) {
42124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42125 }
42126 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42127 {
42128 PyThreadState* __tstate = wxPyBeginAllowThreads();
42129 (arg1)->Detach();
42130 wxPyEndAllowThreads(__tstate);
42131 if (PyErr_Occurred()) SWIG_fail;
42132 }
42133 resultobj = SWIG_Py_Void();
42134 return resultobj;
42135 fail:
42136 return NULL;
42137 }
42138
42139
42140 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42141 PyObject *resultobj = 0;
42142 bool arg1 ;
42143 bool val1 ;
42144 int ecode1 = 0 ;
42145 PyObject * obj0 = 0 ;
42146 char * kwnames[] = {
42147 (char *) "enable", NULL
42148 };
42149
42150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42151 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42152 if (!SWIG_IsOK(ecode1)) {
42153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42154 }
42155 arg1 = static_cast< bool >(val1);
42156 {
42157 PyThreadState* __tstate = wxPyBeginAllowThreads();
42158 wxMenuBar::SetAutoWindowMenu(arg1);
42159 wxPyEndAllowThreads(__tstate);
42160 if (PyErr_Occurred()) SWIG_fail;
42161 }
42162 resultobj = SWIG_Py_Void();
42163 return resultobj;
42164 fail:
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42170 PyObject *resultobj = 0;
42171 bool result;
42172
42173 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42174 {
42175 PyThreadState* __tstate = wxPyBeginAllowThreads();
42176 result = (bool)wxMenuBar::GetAutoWindowMenu();
42177 wxPyEndAllowThreads(__tstate);
42178 if (PyErr_Occurred()) SWIG_fail;
42179 }
42180 {
42181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42182 }
42183 return resultobj;
42184 fail:
42185 return NULL;
42186 }
42187
42188
42189 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42190 PyObject *obj;
42191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42192 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42193 return SWIG_Py_Void();
42194 }
42195
42196 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42197 return SWIG_Python_InitShadowInstance(args);
42198 }
42199
42200 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42201 PyObject *resultobj = 0;
42202 wxMenu *arg1 = (wxMenu *) NULL ;
42203 int arg2 = (int) wxID_ANY ;
42204 wxString const &arg3_defvalue = wxPyEmptyString ;
42205 wxString *arg3 = (wxString *) &arg3_defvalue ;
42206 wxString const &arg4_defvalue = wxPyEmptyString ;
42207 wxString *arg4 = (wxString *) &arg4_defvalue ;
42208 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42209 wxMenu *arg6 = (wxMenu *) NULL ;
42210 wxMenuItem *result = 0 ;
42211 void *argp1 = 0 ;
42212 int res1 = 0 ;
42213 int val2 ;
42214 int ecode2 = 0 ;
42215 bool temp3 = false ;
42216 bool temp4 = false ;
42217 int val5 ;
42218 int ecode5 = 0 ;
42219 void *argp6 = 0 ;
42220 int res6 = 0 ;
42221 PyObject * obj0 = 0 ;
42222 PyObject * obj1 = 0 ;
42223 PyObject * obj2 = 0 ;
42224 PyObject * obj3 = 0 ;
42225 PyObject * obj4 = 0 ;
42226 PyObject * obj5 = 0 ;
42227 char * kwnames[] = {
42228 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42229 };
42230
42231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42232 if (obj0) {
42233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42234 if (!SWIG_IsOK(res1)) {
42235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42236 }
42237 arg1 = reinterpret_cast< wxMenu * >(argp1);
42238 }
42239 if (obj1) {
42240 ecode2 = SWIG_AsVal_int(obj1, &val2);
42241 if (!SWIG_IsOK(ecode2)) {
42242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42243 }
42244 arg2 = static_cast< int >(val2);
42245 }
42246 if (obj2) {
42247 {
42248 arg3 = wxString_in_helper(obj2);
42249 if (arg3 == NULL) SWIG_fail;
42250 temp3 = true;
42251 }
42252 }
42253 if (obj3) {
42254 {
42255 arg4 = wxString_in_helper(obj3);
42256 if (arg4 == NULL) SWIG_fail;
42257 temp4 = true;
42258 }
42259 }
42260 if (obj4) {
42261 ecode5 = SWIG_AsVal_int(obj4, &val5);
42262 if (!SWIG_IsOK(ecode5)) {
42263 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42264 }
42265 arg5 = static_cast< wxItemKind >(val5);
42266 }
42267 if (obj5) {
42268 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42269 if (!SWIG_IsOK(res6)) {
42270 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42271 }
42272 arg6 = reinterpret_cast< wxMenu * >(argp6);
42273 }
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42277 wxPyEndAllowThreads(__tstate);
42278 if (PyErr_Occurred()) SWIG_fail;
42279 }
42280 {
42281 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42282 }
42283 {
42284 if (temp3)
42285 delete arg3;
42286 }
42287 {
42288 if (temp4)
42289 delete arg4;
42290 }
42291 return resultobj;
42292 fail:
42293 {
42294 if (temp3)
42295 delete arg3;
42296 }
42297 {
42298 if (temp4)
42299 delete arg4;
42300 }
42301 return NULL;
42302 }
42303
42304
42305 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42306 PyObject *resultobj = 0;
42307 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42308 void *argp1 = 0 ;
42309 int res1 = 0 ;
42310 PyObject *swig_obj[1] ;
42311
42312 if (!args) SWIG_fail;
42313 swig_obj[0] = args;
42314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42315 if (!SWIG_IsOK(res1)) {
42316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42317 }
42318 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42319 {
42320 PyThreadState* __tstate = wxPyBeginAllowThreads();
42321 delete arg1;
42322
42323 wxPyEndAllowThreads(__tstate);
42324 if (PyErr_Occurred()) SWIG_fail;
42325 }
42326 resultobj = SWIG_Py_Void();
42327 return resultobj;
42328 fail:
42329 return NULL;
42330 }
42331
42332
42333 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42334 PyObject *resultobj = 0;
42335 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42336 wxMenu *result = 0 ;
42337 void *argp1 = 0 ;
42338 int res1 = 0 ;
42339 PyObject *swig_obj[1] ;
42340
42341 if (!args) SWIG_fail;
42342 swig_obj[0] = args;
42343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42344 if (!SWIG_IsOK(res1)) {
42345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42346 }
42347 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42348 {
42349 PyThreadState* __tstate = wxPyBeginAllowThreads();
42350 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42351 wxPyEndAllowThreads(__tstate);
42352 if (PyErr_Occurred()) SWIG_fail;
42353 }
42354 {
42355 resultobj = wxPyMake_wxObject(result, 0);
42356 }
42357 return resultobj;
42358 fail:
42359 return NULL;
42360 }
42361
42362
42363 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42364 PyObject *resultobj = 0;
42365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42366 wxMenu *arg2 = (wxMenu *) 0 ;
42367 void *argp1 = 0 ;
42368 int res1 = 0 ;
42369 void *argp2 = 0 ;
42370 int res2 = 0 ;
42371 PyObject * obj0 = 0 ;
42372 PyObject * obj1 = 0 ;
42373 char * kwnames[] = {
42374 (char *) "self",(char *) "menu", NULL
42375 };
42376
42377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42379 if (!SWIG_IsOK(res1)) {
42380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42381 }
42382 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42384 if (!SWIG_IsOK(res2)) {
42385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42386 }
42387 arg2 = reinterpret_cast< wxMenu * >(argp2);
42388 {
42389 PyThreadState* __tstate = wxPyBeginAllowThreads();
42390 (arg1)->SetMenu(arg2);
42391 wxPyEndAllowThreads(__tstate);
42392 if (PyErr_Occurred()) SWIG_fail;
42393 }
42394 resultobj = SWIG_Py_Void();
42395 return resultobj;
42396 fail:
42397 return NULL;
42398 }
42399
42400
42401 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42402 PyObject *resultobj = 0;
42403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42404 int arg2 ;
42405 void *argp1 = 0 ;
42406 int res1 = 0 ;
42407 int val2 ;
42408 int ecode2 = 0 ;
42409 PyObject * obj0 = 0 ;
42410 PyObject * obj1 = 0 ;
42411 char * kwnames[] = {
42412 (char *) "self",(char *) "id", NULL
42413 };
42414
42415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42417 if (!SWIG_IsOK(res1)) {
42418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42419 }
42420 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42421 ecode2 = SWIG_AsVal_int(obj1, &val2);
42422 if (!SWIG_IsOK(ecode2)) {
42423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42424 }
42425 arg2 = static_cast< int >(val2);
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 (arg1)->SetId(arg2);
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 resultobj = SWIG_Py_Void();
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42440 PyObject *resultobj = 0;
42441 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42442 int result;
42443 void *argp1 = 0 ;
42444 int res1 = 0 ;
42445 PyObject *swig_obj[1] ;
42446
42447 if (!args) SWIG_fail;
42448 swig_obj[0] = args;
42449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42450 if (!SWIG_IsOK(res1)) {
42451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42452 }
42453 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42454 {
42455 PyThreadState* __tstate = wxPyBeginAllowThreads();
42456 result = (int)((wxMenuItem const *)arg1)->GetId();
42457 wxPyEndAllowThreads(__tstate);
42458 if (PyErr_Occurred()) SWIG_fail;
42459 }
42460 resultobj = SWIG_From_int(static_cast< int >(result));
42461 return resultobj;
42462 fail:
42463 return NULL;
42464 }
42465
42466
42467 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42468 PyObject *resultobj = 0;
42469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42470 bool result;
42471 void *argp1 = 0 ;
42472 int res1 = 0 ;
42473 PyObject *swig_obj[1] ;
42474
42475 if (!args) SWIG_fail;
42476 swig_obj[0] = args;
42477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42478 if (!SWIG_IsOK(res1)) {
42479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42480 }
42481 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42482 {
42483 PyThreadState* __tstate = wxPyBeginAllowThreads();
42484 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42485 wxPyEndAllowThreads(__tstate);
42486 if (PyErr_Occurred()) SWIG_fail;
42487 }
42488 {
42489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42490 }
42491 return resultobj;
42492 fail:
42493 return NULL;
42494 }
42495
42496
42497 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42498 PyObject *resultobj = 0;
42499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42500 wxString *arg2 = 0 ;
42501 void *argp1 = 0 ;
42502 int res1 = 0 ;
42503 bool temp2 = false ;
42504 PyObject * obj0 = 0 ;
42505 PyObject * obj1 = 0 ;
42506 char * kwnames[] = {
42507 (char *) "self",(char *) "str", NULL
42508 };
42509
42510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42512 if (!SWIG_IsOK(res1)) {
42513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42514 }
42515 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42516 {
42517 arg2 = wxString_in_helper(obj1);
42518 if (arg2 == NULL) SWIG_fail;
42519 temp2 = true;
42520 }
42521 {
42522 PyThreadState* __tstate = wxPyBeginAllowThreads();
42523 (arg1)->SetText((wxString const &)*arg2);
42524 wxPyEndAllowThreads(__tstate);
42525 if (PyErr_Occurred()) SWIG_fail;
42526 }
42527 resultobj = SWIG_Py_Void();
42528 {
42529 if (temp2)
42530 delete arg2;
42531 }
42532 return resultobj;
42533 fail:
42534 {
42535 if (temp2)
42536 delete arg2;
42537 }
42538 return NULL;
42539 }
42540
42541
42542 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42543 PyObject *resultobj = 0;
42544 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42545 wxString result;
42546 void *argp1 = 0 ;
42547 int res1 = 0 ;
42548 PyObject *swig_obj[1] ;
42549
42550 if (!args) SWIG_fail;
42551 swig_obj[0] = args;
42552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42553 if (!SWIG_IsOK(res1)) {
42554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42555 }
42556 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42557 {
42558 PyThreadState* __tstate = wxPyBeginAllowThreads();
42559 result = ((wxMenuItem const *)arg1)->GetLabel();
42560 wxPyEndAllowThreads(__tstate);
42561 if (PyErr_Occurred()) SWIG_fail;
42562 }
42563 {
42564 #if wxUSE_UNICODE
42565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42566 #else
42567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42568 #endif
42569 }
42570 return resultobj;
42571 fail:
42572 return NULL;
42573 }
42574
42575
42576 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42577 PyObject *resultobj = 0;
42578 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42579 wxString *result = 0 ;
42580 void *argp1 = 0 ;
42581 int res1 = 0 ;
42582 PyObject *swig_obj[1] ;
42583
42584 if (!args) SWIG_fail;
42585 swig_obj[0] = args;
42586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42587 if (!SWIG_IsOK(res1)) {
42588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42589 }
42590 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42591 {
42592 PyThreadState* __tstate = wxPyBeginAllowThreads();
42593 {
42594 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42595 result = (wxString *) &_result_ref;
42596 }
42597 wxPyEndAllowThreads(__tstate);
42598 if (PyErr_Occurred()) SWIG_fail;
42599 }
42600 {
42601 #if wxUSE_UNICODE
42602 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42603 #else
42604 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42605 #endif
42606 }
42607 return resultobj;
42608 fail:
42609 return NULL;
42610 }
42611
42612
42613 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42614 PyObject *resultobj = 0;
42615 wxString *arg1 = 0 ;
42616 wxString result;
42617 bool temp1 = false ;
42618 PyObject * obj0 = 0 ;
42619 char * kwnames[] = {
42620 (char *) "text", NULL
42621 };
42622
42623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42624 {
42625 arg1 = wxString_in_helper(obj0);
42626 if (arg1 == NULL) SWIG_fail;
42627 temp1 = true;
42628 }
42629 {
42630 PyThreadState* __tstate = wxPyBeginAllowThreads();
42631 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42632 wxPyEndAllowThreads(__tstate);
42633 if (PyErr_Occurred()) SWIG_fail;
42634 }
42635 {
42636 #if wxUSE_UNICODE
42637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42638 #else
42639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42640 #endif
42641 }
42642 {
42643 if (temp1)
42644 delete arg1;
42645 }
42646 return resultobj;
42647 fail:
42648 {
42649 if (temp1)
42650 delete arg1;
42651 }
42652 return NULL;
42653 }
42654
42655
42656 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42657 PyObject *resultobj = 0;
42658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42659 wxItemKind result;
42660 void *argp1 = 0 ;
42661 int res1 = 0 ;
42662 PyObject *swig_obj[1] ;
42663
42664 if (!args) SWIG_fail;
42665 swig_obj[0] = args;
42666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42667 if (!SWIG_IsOK(res1)) {
42668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42669 }
42670 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42671 {
42672 PyThreadState* __tstate = wxPyBeginAllowThreads();
42673 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42674 wxPyEndAllowThreads(__tstate);
42675 if (PyErr_Occurred()) SWIG_fail;
42676 }
42677 resultobj = SWIG_From_int(static_cast< int >(result));
42678 return resultobj;
42679 fail:
42680 return NULL;
42681 }
42682
42683
42684 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42685 PyObject *resultobj = 0;
42686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42687 wxItemKind arg2 ;
42688 void *argp1 = 0 ;
42689 int res1 = 0 ;
42690 int val2 ;
42691 int ecode2 = 0 ;
42692 PyObject * obj0 = 0 ;
42693 PyObject * obj1 = 0 ;
42694 char * kwnames[] = {
42695 (char *) "self",(char *) "kind", NULL
42696 };
42697
42698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42700 if (!SWIG_IsOK(res1)) {
42701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42702 }
42703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42704 ecode2 = SWIG_AsVal_int(obj1, &val2);
42705 if (!SWIG_IsOK(ecode2)) {
42706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42707 }
42708 arg2 = static_cast< wxItemKind >(val2);
42709 {
42710 PyThreadState* __tstate = wxPyBeginAllowThreads();
42711 (arg1)->SetKind(arg2);
42712 wxPyEndAllowThreads(__tstate);
42713 if (PyErr_Occurred()) SWIG_fail;
42714 }
42715 resultobj = SWIG_Py_Void();
42716 return resultobj;
42717 fail:
42718 return NULL;
42719 }
42720
42721
42722 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42723 PyObject *resultobj = 0;
42724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42725 bool arg2 ;
42726 void *argp1 = 0 ;
42727 int res1 = 0 ;
42728 bool val2 ;
42729 int ecode2 = 0 ;
42730 PyObject * obj0 = 0 ;
42731 PyObject * obj1 = 0 ;
42732 char * kwnames[] = {
42733 (char *) "self",(char *) "checkable", NULL
42734 };
42735
42736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42738 if (!SWIG_IsOK(res1)) {
42739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42740 }
42741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42743 if (!SWIG_IsOK(ecode2)) {
42744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42745 }
42746 arg2 = static_cast< bool >(val2);
42747 {
42748 PyThreadState* __tstate = wxPyBeginAllowThreads();
42749 (arg1)->SetCheckable(arg2);
42750 wxPyEndAllowThreads(__tstate);
42751 if (PyErr_Occurred()) SWIG_fail;
42752 }
42753 resultobj = SWIG_Py_Void();
42754 return resultobj;
42755 fail:
42756 return NULL;
42757 }
42758
42759
42760 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42761 PyObject *resultobj = 0;
42762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42763 bool result;
42764 void *argp1 = 0 ;
42765 int res1 = 0 ;
42766 PyObject *swig_obj[1] ;
42767
42768 if (!args) SWIG_fail;
42769 swig_obj[0] = args;
42770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42771 if (!SWIG_IsOK(res1)) {
42772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42773 }
42774 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42775 {
42776 PyThreadState* __tstate = wxPyBeginAllowThreads();
42777 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42778 wxPyEndAllowThreads(__tstate);
42779 if (PyErr_Occurred()) SWIG_fail;
42780 }
42781 {
42782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42783 }
42784 return resultobj;
42785 fail:
42786 return NULL;
42787 }
42788
42789
42790 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42791 PyObject *resultobj = 0;
42792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42793 bool result;
42794 void *argp1 = 0 ;
42795 int res1 = 0 ;
42796 PyObject *swig_obj[1] ;
42797
42798 if (!args) SWIG_fail;
42799 swig_obj[0] = args;
42800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42801 if (!SWIG_IsOK(res1)) {
42802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42803 }
42804 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42805 {
42806 PyThreadState* __tstate = wxPyBeginAllowThreads();
42807 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42808 wxPyEndAllowThreads(__tstate);
42809 if (PyErr_Occurred()) SWIG_fail;
42810 }
42811 {
42812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42813 }
42814 return resultobj;
42815 fail:
42816 return NULL;
42817 }
42818
42819
42820 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42821 PyObject *resultobj = 0;
42822 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42823 wxMenu *arg2 = (wxMenu *) 0 ;
42824 void *argp1 = 0 ;
42825 int res1 = 0 ;
42826 void *argp2 = 0 ;
42827 int res2 = 0 ;
42828 PyObject * obj0 = 0 ;
42829 PyObject * obj1 = 0 ;
42830 char * kwnames[] = {
42831 (char *) "self",(char *) "menu", NULL
42832 };
42833
42834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42836 if (!SWIG_IsOK(res1)) {
42837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42838 }
42839 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42841 if (!SWIG_IsOK(res2)) {
42842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42843 }
42844 arg2 = reinterpret_cast< wxMenu * >(argp2);
42845 {
42846 PyThreadState* __tstate = wxPyBeginAllowThreads();
42847 (arg1)->SetSubMenu(arg2);
42848 wxPyEndAllowThreads(__tstate);
42849 if (PyErr_Occurred()) SWIG_fail;
42850 }
42851 resultobj = SWIG_Py_Void();
42852 return resultobj;
42853 fail:
42854 return NULL;
42855 }
42856
42857
42858 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42859 PyObject *resultobj = 0;
42860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42861 wxMenu *result = 0 ;
42862 void *argp1 = 0 ;
42863 int res1 = 0 ;
42864 PyObject *swig_obj[1] ;
42865
42866 if (!args) SWIG_fail;
42867 swig_obj[0] = args;
42868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42869 if (!SWIG_IsOK(res1)) {
42870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42871 }
42872 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42873 {
42874 PyThreadState* __tstate = wxPyBeginAllowThreads();
42875 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42876 wxPyEndAllowThreads(__tstate);
42877 if (PyErr_Occurred()) SWIG_fail;
42878 }
42879 {
42880 resultobj = wxPyMake_wxObject(result, 0);
42881 }
42882 return resultobj;
42883 fail:
42884 return NULL;
42885 }
42886
42887
42888 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42889 PyObject *resultobj = 0;
42890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42891 bool arg2 = (bool) true ;
42892 void *argp1 = 0 ;
42893 int res1 = 0 ;
42894 bool val2 ;
42895 int ecode2 = 0 ;
42896 PyObject * obj0 = 0 ;
42897 PyObject * obj1 = 0 ;
42898 char * kwnames[] = {
42899 (char *) "self",(char *) "enable", NULL
42900 };
42901
42902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42904 if (!SWIG_IsOK(res1)) {
42905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42906 }
42907 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42908 if (obj1) {
42909 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42910 if (!SWIG_IsOK(ecode2)) {
42911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42912 }
42913 arg2 = static_cast< bool >(val2);
42914 }
42915 {
42916 PyThreadState* __tstate = wxPyBeginAllowThreads();
42917 (arg1)->Enable(arg2);
42918 wxPyEndAllowThreads(__tstate);
42919 if (PyErr_Occurred()) SWIG_fail;
42920 }
42921 resultobj = SWIG_Py_Void();
42922 return resultobj;
42923 fail:
42924 return NULL;
42925 }
42926
42927
42928 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42929 PyObject *resultobj = 0;
42930 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42931 bool result;
42932 void *argp1 = 0 ;
42933 int res1 = 0 ;
42934 PyObject *swig_obj[1] ;
42935
42936 if (!args) SWIG_fail;
42937 swig_obj[0] = args;
42938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42939 if (!SWIG_IsOK(res1)) {
42940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42941 }
42942 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42943 {
42944 PyThreadState* __tstate = wxPyBeginAllowThreads();
42945 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 {
42950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42951 }
42952 return resultobj;
42953 fail:
42954 return NULL;
42955 }
42956
42957
42958 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42959 PyObject *resultobj = 0;
42960 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42961 bool arg2 = (bool) true ;
42962 void *argp1 = 0 ;
42963 int res1 = 0 ;
42964 bool val2 ;
42965 int ecode2 = 0 ;
42966 PyObject * obj0 = 0 ;
42967 PyObject * obj1 = 0 ;
42968 char * kwnames[] = {
42969 (char *) "self",(char *) "check", NULL
42970 };
42971
42972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42974 if (!SWIG_IsOK(res1)) {
42975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42976 }
42977 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42978 if (obj1) {
42979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42980 if (!SWIG_IsOK(ecode2)) {
42981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42982 }
42983 arg2 = static_cast< bool >(val2);
42984 }
42985 {
42986 PyThreadState* __tstate = wxPyBeginAllowThreads();
42987 (arg1)->Check(arg2);
42988 wxPyEndAllowThreads(__tstate);
42989 if (PyErr_Occurred()) SWIG_fail;
42990 }
42991 resultobj = SWIG_Py_Void();
42992 return resultobj;
42993 fail:
42994 return NULL;
42995 }
42996
42997
42998 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42999 PyObject *resultobj = 0;
43000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43001 bool result;
43002 void *argp1 = 0 ;
43003 int res1 = 0 ;
43004 PyObject *swig_obj[1] ;
43005
43006 if (!args) SWIG_fail;
43007 swig_obj[0] = args;
43008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43009 if (!SWIG_IsOK(res1)) {
43010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43011 }
43012 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43016 wxPyEndAllowThreads(__tstate);
43017 if (PyErr_Occurred()) SWIG_fail;
43018 }
43019 {
43020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43021 }
43022 return resultobj;
43023 fail:
43024 return NULL;
43025 }
43026
43027
43028 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43029 PyObject *resultobj = 0;
43030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43031 void *argp1 = 0 ;
43032 int res1 = 0 ;
43033 PyObject *swig_obj[1] ;
43034
43035 if (!args) SWIG_fail;
43036 swig_obj[0] = args;
43037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43038 if (!SWIG_IsOK(res1)) {
43039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43040 }
43041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43042 {
43043 PyThreadState* __tstate = wxPyBeginAllowThreads();
43044 (arg1)->Toggle();
43045 wxPyEndAllowThreads(__tstate);
43046 if (PyErr_Occurred()) SWIG_fail;
43047 }
43048 resultobj = SWIG_Py_Void();
43049 return resultobj;
43050 fail:
43051 return NULL;
43052 }
43053
43054
43055 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43056 PyObject *resultobj = 0;
43057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43058 wxString *arg2 = 0 ;
43059 void *argp1 = 0 ;
43060 int res1 = 0 ;
43061 bool temp2 = false ;
43062 PyObject * obj0 = 0 ;
43063 PyObject * obj1 = 0 ;
43064 char * kwnames[] = {
43065 (char *) "self",(char *) "str", NULL
43066 };
43067
43068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43070 if (!SWIG_IsOK(res1)) {
43071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43072 }
43073 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43074 {
43075 arg2 = wxString_in_helper(obj1);
43076 if (arg2 == NULL) SWIG_fail;
43077 temp2 = true;
43078 }
43079 {
43080 PyThreadState* __tstate = wxPyBeginAllowThreads();
43081 (arg1)->SetHelp((wxString const &)*arg2);
43082 wxPyEndAllowThreads(__tstate);
43083 if (PyErr_Occurred()) SWIG_fail;
43084 }
43085 resultobj = SWIG_Py_Void();
43086 {
43087 if (temp2)
43088 delete arg2;
43089 }
43090 return resultobj;
43091 fail:
43092 {
43093 if (temp2)
43094 delete arg2;
43095 }
43096 return NULL;
43097 }
43098
43099
43100 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43101 PyObject *resultobj = 0;
43102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43103 wxString *result = 0 ;
43104 void *argp1 = 0 ;
43105 int res1 = 0 ;
43106 PyObject *swig_obj[1] ;
43107
43108 if (!args) SWIG_fail;
43109 swig_obj[0] = args;
43110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43111 if (!SWIG_IsOK(res1)) {
43112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43113 }
43114 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43115 {
43116 PyThreadState* __tstate = wxPyBeginAllowThreads();
43117 {
43118 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43119 result = (wxString *) &_result_ref;
43120 }
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 {
43125 #if wxUSE_UNICODE
43126 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43127 #else
43128 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43129 #endif
43130 }
43131 return resultobj;
43132 fail:
43133 return NULL;
43134 }
43135
43136
43137 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43138 PyObject *resultobj = 0;
43139 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43140 wxAcceleratorEntry *result = 0 ;
43141 void *argp1 = 0 ;
43142 int res1 = 0 ;
43143 PyObject *swig_obj[1] ;
43144
43145 if (!args) SWIG_fail;
43146 swig_obj[0] = args;
43147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43148 if (!SWIG_IsOK(res1)) {
43149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43150 }
43151 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43152 {
43153 PyThreadState* __tstate = wxPyBeginAllowThreads();
43154 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43155 wxPyEndAllowThreads(__tstate);
43156 if (PyErr_Occurred()) SWIG_fail;
43157 }
43158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43159 return resultobj;
43160 fail:
43161 return NULL;
43162 }
43163
43164
43165 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43166 PyObject *resultobj = 0;
43167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43168 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43169 void *argp1 = 0 ;
43170 int res1 = 0 ;
43171 void *argp2 = 0 ;
43172 int res2 = 0 ;
43173 PyObject * obj0 = 0 ;
43174 PyObject * obj1 = 0 ;
43175 char * kwnames[] = {
43176 (char *) "self",(char *) "accel", NULL
43177 };
43178
43179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43181 if (!SWIG_IsOK(res1)) {
43182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43183 }
43184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43186 if (!SWIG_IsOK(res2)) {
43187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43188 }
43189 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43190 {
43191 PyThreadState* __tstate = wxPyBeginAllowThreads();
43192 (arg1)->SetAccel(arg2);
43193 wxPyEndAllowThreads(__tstate);
43194 if (PyErr_Occurred()) SWIG_fail;
43195 }
43196 resultobj = SWIG_Py_Void();
43197 return resultobj;
43198 fail:
43199 return NULL;
43200 }
43201
43202
43203 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43204 PyObject *resultobj = 0;
43205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43206 wxBitmap *arg2 = 0 ;
43207 void *argp1 = 0 ;
43208 int res1 = 0 ;
43209 void *argp2 = 0 ;
43210 int res2 = 0 ;
43211 PyObject * obj0 = 0 ;
43212 PyObject * obj1 = 0 ;
43213 char * kwnames[] = {
43214 (char *) "self",(char *) "bitmap", NULL
43215 };
43216
43217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43219 if (!SWIG_IsOK(res1)) {
43220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43221 }
43222 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43223 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43224 if (!SWIG_IsOK(res2)) {
43225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43226 }
43227 if (!argp2) {
43228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43229 }
43230 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43234 wxPyEndAllowThreads(__tstate);
43235 if (PyErr_Occurred()) SWIG_fail;
43236 }
43237 resultobj = SWIG_Py_Void();
43238 return resultobj;
43239 fail:
43240 return NULL;
43241 }
43242
43243
43244 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43245 PyObject *resultobj = 0;
43246 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43247 wxBitmap *result = 0 ;
43248 void *argp1 = 0 ;
43249 int res1 = 0 ;
43250 PyObject *swig_obj[1] ;
43251
43252 if (!args) SWIG_fail;
43253 swig_obj[0] = args;
43254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43255 if (!SWIG_IsOK(res1)) {
43256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43257 }
43258 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43259 {
43260 PyThreadState* __tstate = wxPyBeginAllowThreads();
43261 {
43262 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43263 result = (wxBitmap *) &_result_ref;
43264 }
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 {
43269 wxBitmap* resultptr = new wxBitmap(*result);
43270 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43271 }
43272 return resultobj;
43273 fail:
43274 return NULL;
43275 }
43276
43277
43278 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43279 PyObject *resultobj = 0;
43280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43281 wxFont *arg2 = 0 ;
43282 void *argp1 = 0 ;
43283 int res1 = 0 ;
43284 void *argp2 = 0 ;
43285 int res2 = 0 ;
43286 PyObject * obj0 = 0 ;
43287 PyObject * obj1 = 0 ;
43288 char * kwnames[] = {
43289 (char *) "self",(char *) "font", NULL
43290 };
43291
43292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43294 if (!SWIG_IsOK(res1)) {
43295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43296 }
43297 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43299 if (!SWIG_IsOK(res2)) {
43300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43301 }
43302 if (!argp2) {
43303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43304 }
43305 arg2 = reinterpret_cast< wxFont * >(argp2);
43306 {
43307 PyThreadState* __tstate = wxPyBeginAllowThreads();
43308 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 resultobj = SWIG_Py_Void();
43313 return resultobj;
43314 fail:
43315 return NULL;
43316 }
43317
43318
43319 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43320 PyObject *resultobj = 0;
43321 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43322 wxFont result;
43323 void *argp1 = 0 ;
43324 int res1 = 0 ;
43325 PyObject *swig_obj[1] ;
43326
43327 if (!args) SWIG_fail;
43328 swig_obj[0] = args;
43329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43330 if (!SWIG_IsOK(res1)) {
43331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43332 }
43333 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43334 {
43335 PyThreadState* __tstate = wxPyBeginAllowThreads();
43336 result = wxMenuItem_GetFont(arg1);
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43341 return resultobj;
43342 fail:
43343 return NULL;
43344 }
43345
43346
43347 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43348 PyObject *resultobj = 0;
43349 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43350 wxColour *arg2 = 0 ;
43351 void *argp1 = 0 ;
43352 int res1 = 0 ;
43353 wxColour temp2 ;
43354 PyObject * obj0 = 0 ;
43355 PyObject * obj1 = 0 ;
43356 char * kwnames[] = {
43357 (char *) "self",(char *) "colText", NULL
43358 };
43359
43360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43362 if (!SWIG_IsOK(res1)) {
43363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43364 }
43365 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43366 {
43367 arg2 = &temp2;
43368 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43369 }
43370 {
43371 PyThreadState* __tstate = wxPyBeginAllowThreads();
43372 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43373 wxPyEndAllowThreads(__tstate);
43374 if (PyErr_Occurred()) SWIG_fail;
43375 }
43376 resultobj = SWIG_Py_Void();
43377 return resultobj;
43378 fail:
43379 return NULL;
43380 }
43381
43382
43383 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43384 PyObject *resultobj = 0;
43385 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43386 wxColour result;
43387 void *argp1 = 0 ;
43388 int res1 = 0 ;
43389 PyObject *swig_obj[1] ;
43390
43391 if (!args) SWIG_fail;
43392 swig_obj[0] = args;
43393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43394 if (!SWIG_IsOK(res1)) {
43395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43396 }
43397 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43398 {
43399 PyThreadState* __tstate = wxPyBeginAllowThreads();
43400 result = wxMenuItem_GetTextColour(arg1);
43401 wxPyEndAllowThreads(__tstate);
43402 if (PyErr_Occurred()) SWIG_fail;
43403 }
43404 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43405 return resultobj;
43406 fail:
43407 return NULL;
43408 }
43409
43410
43411 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43412 PyObject *resultobj = 0;
43413 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43414 wxColour *arg2 = 0 ;
43415 void *argp1 = 0 ;
43416 int res1 = 0 ;
43417 wxColour temp2 ;
43418 PyObject * obj0 = 0 ;
43419 PyObject * obj1 = 0 ;
43420 char * kwnames[] = {
43421 (char *) "self",(char *) "colBack", NULL
43422 };
43423
43424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43426 if (!SWIG_IsOK(res1)) {
43427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43428 }
43429 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43430 {
43431 arg2 = &temp2;
43432 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43433 }
43434 {
43435 PyThreadState* __tstate = wxPyBeginAllowThreads();
43436 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43437 wxPyEndAllowThreads(__tstate);
43438 if (PyErr_Occurred()) SWIG_fail;
43439 }
43440 resultobj = SWIG_Py_Void();
43441 return resultobj;
43442 fail:
43443 return NULL;
43444 }
43445
43446
43447 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43448 PyObject *resultobj = 0;
43449 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43450 wxColour result;
43451 void *argp1 = 0 ;
43452 int res1 = 0 ;
43453 PyObject *swig_obj[1] ;
43454
43455 if (!args) SWIG_fail;
43456 swig_obj[0] = args;
43457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43458 if (!SWIG_IsOK(res1)) {
43459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43460 }
43461 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43462 {
43463 PyThreadState* __tstate = wxPyBeginAllowThreads();
43464 result = wxMenuItem_GetBackgroundColour(arg1);
43465 wxPyEndAllowThreads(__tstate);
43466 if (PyErr_Occurred()) SWIG_fail;
43467 }
43468 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43469 return resultobj;
43470 fail:
43471 return NULL;
43472 }
43473
43474
43475 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43476 PyObject *resultobj = 0;
43477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43478 wxBitmap *arg2 = 0 ;
43479 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43480 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43481 void *argp1 = 0 ;
43482 int res1 = 0 ;
43483 void *argp2 = 0 ;
43484 int res2 = 0 ;
43485 void *argp3 = 0 ;
43486 int res3 = 0 ;
43487 PyObject * obj0 = 0 ;
43488 PyObject * obj1 = 0 ;
43489 PyObject * obj2 = 0 ;
43490 char * kwnames[] = {
43491 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43492 };
43493
43494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43496 if (!SWIG_IsOK(res1)) {
43497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43498 }
43499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43500 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43501 if (!SWIG_IsOK(res2)) {
43502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43503 }
43504 if (!argp2) {
43505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43506 }
43507 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43508 if (obj2) {
43509 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43510 if (!SWIG_IsOK(res3)) {
43511 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43512 }
43513 if (!argp3) {
43514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43515 }
43516 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43517 }
43518 {
43519 PyThreadState* __tstate = wxPyBeginAllowThreads();
43520 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43521 wxPyEndAllowThreads(__tstate);
43522 if (PyErr_Occurred()) SWIG_fail;
43523 }
43524 resultobj = SWIG_Py_Void();
43525 return resultobj;
43526 fail:
43527 return NULL;
43528 }
43529
43530
43531 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43532 PyObject *resultobj = 0;
43533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43534 wxBitmap *arg2 = 0 ;
43535 void *argp1 = 0 ;
43536 int res1 = 0 ;
43537 void *argp2 = 0 ;
43538 int res2 = 0 ;
43539 PyObject * obj0 = 0 ;
43540 PyObject * obj1 = 0 ;
43541 char * kwnames[] = {
43542 (char *) "self",(char *) "bmpDisabled", NULL
43543 };
43544
43545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43547 if (!SWIG_IsOK(res1)) {
43548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43549 }
43550 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43552 if (!SWIG_IsOK(res2)) {
43553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43554 }
43555 if (!argp2) {
43556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43557 }
43558 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43559 {
43560 PyThreadState* __tstate = wxPyBeginAllowThreads();
43561 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43562 wxPyEndAllowThreads(__tstate);
43563 if (PyErr_Occurred()) SWIG_fail;
43564 }
43565 resultobj = SWIG_Py_Void();
43566 return resultobj;
43567 fail:
43568 return NULL;
43569 }
43570
43571
43572 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43573 PyObject *resultobj = 0;
43574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43575 wxBitmap *result = 0 ;
43576 void *argp1 = 0 ;
43577 int res1 = 0 ;
43578 PyObject *swig_obj[1] ;
43579
43580 if (!args) SWIG_fail;
43581 swig_obj[0] = args;
43582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43583 if (!SWIG_IsOK(res1)) {
43584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43585 }
43586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 {
43590 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43591 result = (wxBitmap *) &_result_ref;
43592 }
43593 wxPyEndAllowThreads(__tstate);
43594 if (PyErr_Occurred()) SWIG_fail;
43595 }
43596 {
43597 wxBitmap* resultptr = new wxBitmap(*result);
43598 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43599 }
43600 return resultobj;
43601 fail:
43602 return NULL;
43603 }
43604
43605
43606 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43607 PyObject *resultobj = 0;
43608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43609 int arg2 ;
43610 void *argp1 = 0 ;
43611 int res1 = 0 ;
43612 int val2 ;
43613 int ecode2 = 0 ;
43614 PyObject * obj0 = 0 ;
43615 PyObject * obj1 = 0 ;
43616 char * kwnames[] = {
43617 (char *) "self",(char *) "nWidth", NULL
43618 };
43619
43620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43622 if (!SWIG_IsOK(res1)) {
43623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43624 }
43625 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43626 ecode2 = SWIG_AsVal_int(obj1, &val2);
43627 if (!SWIG_IsOK(ecode2)) {
43628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43629 }
43630 arg2 = static_cast< int >(val2);
43631 {
43632 PyThreadState* __tstate = wxPyBeginAllowThreads();
43633 wxMenuItem_SetMarginWidth(arg1,arg2);
43634 wxPyEndAllowThreads(__tstate);
43635 if (PyErr_Occurred()) SWIG_fail;
43636 }
43637 resultobj = SWIG_Py_Void();
43638 return resultobj;
43639 fail:
43640 return NULL;
43641 }
43642
43643
43644 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43645 PyObject *resultobj = 0;
43646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43647 int result;
43648 void *argp1 = 0 ;
43649 int res1 = 0 ;
43650 PyObject *swig_obj[1] ;
43651
43652 if (!args) SWIG_fail;
43653 swig_obj[0] = args;
43654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43655 if (!SWIG_IsOK(res1)) {
43656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43657 }
43658 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43659 {
43660 PyThreadState* __tstate = wxPyBeginAllowThreads();
43661 result = (int)wxMenuItem_GetMarginWidth(arg1);
43662 wxPyEndAllowThreads(__tstate);
43663 if (PyErr_Occurred()) SWIG_fail;
43664 }
43665 resultobj = SWIG_From_int(static_cast< int >(result));
43666 return resultobj;
43667 fail:
43668 return NULL;
43669 }
43670
43671
43672 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43673 PyObject *resultobj = 0;
43674 int result;
43675
43676 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43677 {
43678 PyThreadState* __tstate = wxPyBeginAllowThreads();
43679 result = (int)wxMenuItem_GetDefaultMarginWidth();
43680 wxPyEndAllowThreads(__tstate);
43681 if (PyErr_Occurred()) SWIG_fail;
43682 }
43683 resultobj = SWIG_From_int(static_cast< int >(result));
43684 return resultobj;
43685 fail:
43686 return NULL;
43687 }
43688
43689
43690 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43691 PyObject *resultobj = 0;
43692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43693 bool result;
43694 void *argp1 = 0 ;
43695 int res1 = 0 ;
43696 PyObject *swig_obj[1] ;
43697
43698 if (!args) SWIG_fail;
43699 swig_obj[0] = args;
43700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43701 if (!SWIG_IsOK(res1)) {
43702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43703 }
43704 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43705 {
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43708 wxPyEndAllowThreads(__tstate);
43709 if (PyErr_Occurred()) SWIG_fail;
43710 }
43711 {
43712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43713 }
43714 return resultobj;
43715 fail:
43716 return NULL;
43717 }
43718
43719
43720 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43721 PyObject *resultobj = 0;
43722 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43723 bool arg2 = (bool) true ;
43724 void *argp1 = 0 ;
43725 int res1 = 0 ;
43726 bool val2 ;
43727 int ecode2 = 0 ;
43728 PyObject * obj0 = 0 ;
43729 PyObject * obj1 = 0 ;
43730 char * kwnames[] = {
43731 (char *) "self",(char *) "ownerDrawn", NULL
43732 };
43733
43734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43736 if (!SWIG_IsOK(res1)) {
43737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43738 }
43739 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43740 if (obj1) {
43741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43742 if (!SWIG_IsOK(ecode2)) {
43743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43744 }
43745 arg2 = static_cast< bool >(val2);
43746 }
43747 {
43748 PyThreadState* __tstate = wxPyBeginAllowThreads();
43749 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43750 wxPyEndAllowThreads(__tstate);
43751 if (PyErr_Occurred()) SWIG_fail;
43752 }
43753 resultobj = SWIG_Py_Void();
43754 return resultobj;
43755 fail:
43756 return NULL;
43757 }
43758
43759
43760 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43761 PyObject *resultobj = 0;
43762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43763 void *argp1 = 0 ;
43764 int res1 = 0 ;
43765 PyObject *swig_obj[1] ;
43766
43767 if (!args) SWIG_fail;
43768 swig_obj[0] = args;
43769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43770 if (!SWIG_IsOK(res1)) {
43771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43772 }
43773 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43774 {
43775 PyThreadState* __tstate = wxPyBeginAllowThreads();
43776 wxMenuItem_ResetOwnerDrawn(arg1);
43777 wxPyEndAllowThreads(__tstate);
43778 if (PyErr_Occurred()) SWIG_fail;
43779 }
43780 resultobj = SWIG_Py_Void();
43781 return resultobj;
43782 fail:
43783 return NULL;
43784 }
43785
43786
43787 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43788 PyObject *obj;
43789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43790 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43791 return SWIG_Py_Void();
43792 }
43793
43794 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43795 return SWIG_Python_InitShadowInstance(args);
43796 }
43797
43798 SWIGINTERN int ControlNameStr_set(PyObject *) {
43799 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43800 return 1;
43801 }
43802
43803
43804 SWIGINTERN PyObject *ControlNameStr_get(void) {
43805 PyObject *pyobj = 0;
43806
43807 {
43808 #if wxUSE_UNICODE
43809 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43810 #else
43811 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43812 #endif
43813 }
43814 return pyobj;
43815 }
43816
43817
43818 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43819 PyObject *resultobj = 0;
43820 wxWindow *arg1 = (wxWindow *) 0 ;
43821 int arg2 = (int) -1 ;
43822 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43823 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43824 wxSize const &arg4_defvalue = wxDefaultSize ;
43825 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43826 long arg5 = (long) 0 ;
43827 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43828 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43829 wxString const &arg7_defvalue = wxPyControlNameStr ;
43830 wxString *arg7 = (wxString *) &arg7_defvalue ;
43831 wxControl *result = 0 ;
43832 void *argp1 = 0 ;
43833 int res1 = 0 ;
43834 int val2 ;
43835 int ecode2 = 0 ;
43836 wxPoint temp3 ;
43837 wxSize temp4 ;
43838 long val5 ;
43839 int ecode5 = 0 ;
43840 void *argp6 = 0 ;
43841 int res6 = 0 ;
43842 bool temp7 = false ;
43843 PyObject * obj0 = 0 ;
43844 PyObject * obj1 = 0 ;
43845 PyObject * obj2 = 0 ;
43846 PyObject * obj3 = 0 ;
43847 PyObject * obj4 = 0 ;
43848 PyObject * obj5 = 0 ;
43849 PyObject * obj6 = 0 ;
43850 char * kwnames[] = {
43851 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43852 };
43853
43854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43856 if (!SWIG_IsOK(res1)) {
43857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43858 }
43859 arg1 = reinterpret_cast< wxWindow * >(argp1);
43860 if (obj1) {
43861 ecode2 = SWIG_AsVal_int(obj1, &val2);
43862 if (!SWIG_IsOK(ecode2)) {
43863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43864 }
43865 arg2 = static_cast< int >(val2);
43866 }
43867 if (obj2) {
43868 {
43869 arg3 = &temp3;
43870 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43871 }
43872 }
43873 if (obj3) {
43874 {
43875 arg4 = &temp4;
43876 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43877 }
43878 }
43879 if (obj4) {
43880 ecode5 = SWIG_AsVal_long(obj4, &val5);
43881 if (!SWIG_IsOK(ecode5)) {
43882 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43883 }
43884 arg5 = static_cast< long >(val5);
43885 }
43886 if (obj5) {
43887 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43888 if (!SWIG_IsOK(res6)) {
43889 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43890 }
43891 if (!argp6) {
43892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43893 }
43894 arg6 = reinterpret_cast< wxValidator * >(argp6);
43895 }
43896 if (obj6) {
43897 {
43898 arg7 = wxString_in_helper(obj6);
43899 if (arg7 == NULL) SWIG_fail;
43900 temp7 = true;
43901 }
43902 }
43903 {
43904 if (!wxPyCheckForApp()) SWIG_fail;
43905 PyThreadState* __tstate = wxPyBeginAllowThreads();
43906 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43907 wxPyEndAllowThreads(__tstate);
43908 if (PyErr_Occurred()) SWIG_fail;
43909 }
43910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43911 {
43912 if (temp7)
43913 delete arg7;
43914 }
43915 return resultobj;
43916 fail:
43917 {
43918 if (temp7)
43919 delete arg7;
43920 }
43921 return NULL;
43922 }
43923
43924
43925 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43926 PyObject *resultobj = 0;
43927 wxControl *result = 0 ;
43928
43929 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43930 {
43931 if (!wxPyCheckForApp()) SWIG_fail;
43932 PyThreadState* __tstate = wxPyBeginAllowThreads();
43933 result = (wxControl *)new wxControl();
43934 wxPyEndAllowThreads(__tstate);
43935 if (PyErr_Occurred()) SWIG_fail;
43936 }
43937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43938 return resultobj;
43939 fail:
43940 return NULL;
43941 }
43942
43943
43944 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43945 PyObject *resultobj = 0;
43946 wxControl *arg1 = (wxControl *) 0 ;
43947 wxWindow *arg2 = (wxWindow *) 0 ;
43948 int arg3 = (int) -1 ;
43949 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43950 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43951 wxSize const &arg5_defvalue = wxDefaultSize ;
43952 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43953 long arg6 = (long) 0 ;
43954 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43955 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43956 wxString const &arg8_defvalue = wxPyControlNameStr ;
43957 wxString *arg8 = (wxString *) &arg8_defvalue ;
43958 bool result;
43959 void *argp1 = 0 ;
43960 int res1 = 0 ;
43961 void *argp2 = 0 ;
43962 int res2 = 0 ;
43963 int val3 ;
43964 int ecode3 = 0 ;
43965 wxPoint temp4 ;
43966 wxSize temp5 ;
43967 long val6 ;
43968 int ecode6 = 0 ;
43969 void *argp7 = 0 ;
43970 int res7 = 0 ;
43971 bool temp8 = false ;
43972 PyObject * obj0 = 0 ;
43973 PyObject * obj1 = 0 ;
43974 PyObject * obj2 = 0 ;
43975 PyObject * obj3 = 0 ;
43976 PyObject * obj4 = 0 ;
43977 PyObject * obj5 = 0 ;
43978 PyObject * obj6 = 0 ;
43979 PyObject * obj7 = 0 ;
43980 char * kwnames[] = {
43981 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43982 };
43983
43984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43986 if (!SWIG_IsOK(res1)) {
43987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43988 }
43989 arg1 = reinterpret_cast< wxControl * >(argp1);
43990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43991 if (!SWIG_IsOK(res2)) {
43992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43993 }
43994 arg2 = reinterpret_cast< wxWindow * >(argp2);
43995 if (obj2) {
43996 ecode3 = SWIG_AsVal_int(obj2, &val3);
43997 if (!SWIG_IsOK(ecode3)) {
43998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43999 }
44000 arg3 = static_cast< int >(val3);
44001 }
44002 if (obj3) {
44003 {
44004 arg4 = &temp4;
44005 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44006 }
44007 }
44008 if (obj4) {
44009 {
44010 arg5 = &temp5;
44011 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44012 }
44013 }
44014 if (obj5) {
44015 ecode6 = SWIG_AsVal_long(obj5, &val6);
44016 if (!SWIG_IsOK(ecode6)) {
44017 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44018 }
44019 arg6 = static_cast< long >(val6);
44020 }
44021 if (obj6) {
44022 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44023 if (!SWIG_IsOK(res7)) {
44024 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44025 }
44026 if (!argp7) {
44027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44028 }
44029 arg7 = reinterpret_cast< wxValidator * >(argp7);
44030 }
44031 if (obj7) {
44032 {
44033 arg8 = wxString_in_helper(obj7);
44034 if (arg8 == NULL) SWIG_fail;
44035 temp8 = true;
44036 }
44037 }
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44041 wxPyEndAllowThreads(__tstate);
44042 if (PyErr_Occurred()) SWIG_fail;
44043 }
44044 {
44045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44046 }
44047 {
44048 if (temp8)
44049 delete arg8;
44050 }
44051 return resultobj;
44052 fail:
44053 {
44054 if (temp8)
44055 delete arg8;
44056 }
44057 return NULL;
44058 }
44059
44060
44061 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44062 PyObject *resultobj = 0;
44063 wxControl *arg1 = (wxControl *) 0 ;
44064 wxCommandEvent *arg2 = 0 ;
44065 void *argp1 = 0 ;
44066 int res1 = 0 ;
44067 void *argp2 = 0 ;
44068 int res2 = 0 ;
44069 PyObject * obj0 = 0 ;
44070 PyObject * obj1 = 0 ;
44071 char * kwnames[] = {
44072 (char *) "self",(char *) "event", NULL
44073 };
44074
44075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44077 if (!SWIG_IsOK(res1)) {
44078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44079 }
44080 arg1 = reinterpret_cast< wxControl * >(argp1);
44081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44082 if (!SWIG_IsOK(res2)) {
44083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44084 }
44085 if (!argp2) {
44086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44087 }
44088 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44089 {
44090 PyThreadState* __tstate = wxPyBeginAllowThreads();
44091 (arg1)->Command(*arg2);
44092 wxPyEndAllowThreads(__tstate);
44093 if (PyErr_Occurred()) SWIG_fail;
44094 }
44095 resultobj = SWIG_Py_Void();
44096 return resultobj;
44097 fail:
44098 return NULL;
44099 }
44100
44101
44102 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44103 PyObject *resultobj = 0;
44104 wxControl *arg1 = (wxControl *) 0 ;
44105 wxString result;
44106 void *argp1 = 0 ;
44107 int res1 = 0 ;
44108 PyObject *swig_obj[1] ;
44109
44110 if (!args) SWIG_fail;
44111 swig_obj[0] = args;
44112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44113 if (!SWIG_IsOK(res1)) {
44114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44115 }
44116 arg1 = reinterpret_cast< wxControl * >(argp1);
44117 {
44118 PyThreadState* __tstate = wxPyBeginAllowThreads();
44119 result = (arg1)->GetLabel();
44120 wxPyEndAllowThreads(__tstate);
44121 if (PyErr_Occurred()) SWIG_fail;
44122 }
44123 {
44124 #if wxUSE_UNICODE
44125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44126 #else
44127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44128 #endif
44129 }
44130 return resultobj;
44131 fail:
44132 return NULL;
44133 }
44134
44135
44136 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44137 PyObject *resultobj = 0;
44138 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44139 SwigValueWrapper<wxVisualAttributes > result;
44140 int val1 ;
44141 int ecode1 = 0 ;
44142 PyObject * obj0 = 0 ;
44143 char * kwnames[] = {
44144 (char *) "variant", NULL
44145 };
44146
44147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44148 if (obj0) {
44149 ecode1 = SWIG_AsVal_int(obj0, &val1);
44150 if (!SWIG_IsOK(ecode1)) {
44151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44152 }
44153 arg1 = static_cast< wxWindowVariant >(val1);
44154 }
44155 {
44156 if (!wxPyCheckForApp()) SWIG_fail;
44157 PyThreadState* __tstate = wxPyBeginAllowThreads();
44158 result = wxControl::GetClassDefaultAttributes(arg1);
44159 wxPyEndAllowThreads(__tstate);
44160 if (PyErr_Occurred()) SWIG_fail;
44161 }
44162 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44163 return resultobj;
44164 fail:
44165 return NULL;
44166 }
44167
44168
44169 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44170 PyObject *obj;
44171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44172 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44173 return SWIG_Py_Void();
44174 }
44175
44176 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44177 return SWIG_Python_InitShadowInstance(args);
44178 }
44179
44180 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44181 PyObject *resultobj = 0;
44182 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44183 wxString *arg2 = 0 ;
44184 PyObject *arg3 = (PyObject *) NULL ;
44185 int result;
44186 void *argp1 = 0 ;
44187 int res1 = 0 ;
44188 bool temp2 = false ;
44189 PyObject * obj0 = 0 ;
44190 PyObject * obj1 = 0 ;
44191 PyObject * obj2 = 0 ;
44192 char * kwnames[] = {
44193 (char *) "self",(char *) "item",(char *) "clientData", NULL
44194 };
44195
44196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44198 if (!SWIG_IsOK(res1)) {
44199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44200 }
44201 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44202 {
44203 arg2 = wxString_in_helper(obj1);
44204 if (arg2 == NULL) SWIG_fail;
44205 temp2 = true;
44206 }
44207 if (obj2) {
44208 arg3 = obj2;
44209 }
44210 {
44211 PyThreadState* __tstate = wxPyBeginAllowThreads();
44212 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44213 wxPyEndAllowThreads(__tstate);
44214 if (PyErr_Occurred()) SWIG_fail;
44215 }
44216 resultobj = SWIG_From_int(static_cast< int >(result));
44217 {
44218 if (temp2)
44219 delete arg2;
44220 }
44221 return resultobj;
44222 fail:
44223 {
44224 if (temp2)
44225 delete arg2;
44226 }
44227 return NULL;
44228 }
44229
44230
44231 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44232 PyObject *resultobj = 0;
44233 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44234 wxArrayString *arg2 = 0 ;
44235 void *argp1 = 0 ;
44236 int res1 = 0 ;
44237 bool temp2 = false ;
44238 PyObject * obj0 = 0 ;
44239 PyObject * obj1 = 0 ;
44240 char * kwnames[] = {
44241 (char *) "self",(char *) "strings", NULL
44242 };
44243
44244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44248 }
44249 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44250 {
44251 if (! PySequence_Check(obj1)) {
44252 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44253 SWIG_fail;
44254 }
44255 arg2 = new wxArrayString;
44256 temp2 = true;
44257 int i, len=PySequence_Length(obj1);
44258 for (i=0; i<len; i++) {
44259 PyObject* item = PySequence_GetItem(obj1, i);
44260 wxString* s = wxString_in_helper(item);
44261 if (PyErr_Occurred()) SWIG_fail;
44262 arg2->Add(*s);
44263 delete s;
44264 Py_DECREF(item);
44265 }
44266 }
44267 {
44268 PyThreadState* __tstate = wxPyBeginAllowThreads();
44269 (arg1)->Append((wxArrayString const &)*arg2);
44270 wxPyEndAllowThreads(__tstate);
44271 if (PyErr_Occurred()) SWIG_fail;
44272 }
44273 resultobj = SWIG_Py_Void();
44274 {
44275 if (temp2) delete arg2;
44276 }
44277 return resultobj;
44278 fail:
44279 {
44280 if (temp2) delete arg2;
44281 }
44282 return NULL;
44283 }
44284
44285
44286 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44287 PyObject *resultobj = 0;
44288 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44289 wxString *arg2 = 0 ;
44290 unsigned int arg3 ;
44291 PyObject *arg4 = (PyObject *) NULL ;
44292 int result;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 bool temp2 = false ;
44296 unsigned int val3 ;
44297 int ecode3 = 0 ;
44298 PyObject * obj0 = 0 ;
44299 PyObject * obj1 = 0 ;
44300 PyObject * obj2 = 0 ;
44301 PyObject * obj3 = 0 ;
44302 char * kwnames[] = {
44303 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44304 };
44305
44306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44308 if (!SWIG_IsOK(res1)) {
44309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44310 }
44311 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44312 {
44313 arg2 = wxString_in_helper(obj1);
44314 if (arg2 == NULL) SWIG_fail;
44315 temp2 = true;
44316 }
44317 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44318 if (!SWIG_IsOK(ecode3)) {
44319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44320 }
44321 arg3 = static_cast< unsigned int >(val3);
44322 if (obj3) {
44323 arg4 = obj3;
44324 }
44325 {
44326 PyThreadState* __tstate = wxPyBeginAllowThreads();
44327 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44328 wxPyEndAllowThreads(__tstate);
44329 if (PyErr_Occurred()) SWIG_fail;
44330 }
44331 resultobj = SWIG_From_int(static_cast< int >(result));
44332 {
44333 if (temp2)
44334 delete arg2;
44335 }
44336 return resultobj;
44337 fail:
44338 {
44339 if (temp2)
44340 delete arg2;
44341 }
44342 return NULL;
44343 }
44344
44345
44346 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44347 PyObject *resultobj = 0;
44348 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44349 void *argp1 = 0 ;
44350 int res1 = 0 ;
44351 PyObject *swig_obj[1] ;
44352
44353 if (!args) SWIG_fail;
44354 swig_obj[0] = args;
44355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44356 if (!SWIG_IsOK(res1)) {
44357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44358 }
44359 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44360 {
44361 PyThreadState* __tstate = wxPyBeginAllowThreads();
44362 (arg1)->Clear();
44363 wxPyEndAllowThreads(__tstate);
44364 if (PyErr_Occurred()) SWIG_fail;
44365 }
44366 resultobj = SWIG_Py_Void();
44367 return resultobj;
44368 fail:
44369 return NULL;
44370 }
44371
44372
44373 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44374 PyObject *resultobj = 0;
44375 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44376 unsigned int arg2 ;
44377 void *argp1 = 0 ;
44378 int res1 = 0 ;
44379 unsigned int val2 ;
44380 int ecode2 = 0 ;
44381 PyObject * obj0 = 0 ;
44382 PyObject * obj1 = 0 ;
44383 char * kwnames[] = {
44384 (char *) "self",(char *) "n", NULL
44385 };
44386
44387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44389 if (!SWIG_IsOK(res1)) {
44390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44391 }
44392 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44393 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44394 if (!SWIG_IsOK(ecode2)) {
44395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44396 }
44397 arg2 = static_cast< unsigned int >(val2);
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 (arg1)->Delete(arg2);
44401 wxPyEndAllowThreads(__tstate);
44402 if (PyErr_Occurred()) SWIG_fail;
44403 }
44404 resultobj = SWIG_Py_Void();
44405 return resultobj;
44406 fail:
44407 return NULL;
44408 }
44409
44410
44411 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44412 PyObject *resultobj = 0;
44413 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44414 unsigned int arg2 ;
44415 PyObject *result = 0 ;
44416 void *argp1 = 0 ;
44417 int res1 = 0 ;
44418 unsigned int val2 ;
44419 int ecode2 = 0 ;
44420 PyObject * obj0 = 0 ;
44421 PyObject * obj1 = 0 ;
44422 char * kwnames[] = {
44423 (char *) "self",(char *) "n", NULL
44424 };
44425
44426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44428 if (!SWIG_IsOK(res1)) {
44429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44430 }
44431 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44432 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44433 if (!SWIG_IsOK(ecode2)) {
44434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44435 }
44436 arg2 = static_cast< unsigned int >(val2);
44437 {
44438 PyThreadState* __tstate = wxPyBeginAllowThreads();
44439 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44440 wxPyEndAllowThreads(__tstate);
44441 if (PyErr_Occurred()) SWIG_fail;
44442 }
44443 resultobj = result;
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44451 PyObject *resultobj = 0;
44452 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44453 unsigned int arg2 ;
44454 PyObject *arg3 = (PyObject *) 0 ;
44455 void *argp1 = 0 ;
44456 int res1 = 0 ;
44457 unsigned int val2 ;
44458 int ecode2 = 0 ;
44459 PyObject * obj0 = 0 ;
44460 PyObject * obj1 = 0 ;
44461 PyObject * obj2 = 0 ;
44462 char * kwnames[] = {
44463 (char *) "self",(char *) "n",(char *) "clientData", NULL
44464 };
44465
44466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44468 if (!SWIG_IsOK(res1)) {
44469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44470 }
44471 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44472 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44473 if (!SWIG_IsOK(ecode2)) {
44474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44475 }
44476 arg2 = static_cast< unsigned int >(val2);
44477 arg3 = obj2;
44478 {
44479 PyThreadState* __tstate = wxPyBeginAllowThreads();
44480 wxItemContainer_SetClientData(arg1,arg2,arg3);
44481 wxPyEndAllowThreads(__tstate);
44482 if (PyErr_Occurred()) SWIG_fail;
44483 }
44484 resultobj = SWIG_Py_Void();
44485 return resultobj;
44486 fail:
44487 return NULL;
44488 }
44489
44490
44491 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44492 PyObject *resultobj = 0;
44493 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44494 unsigned int result;
44495 void *argp1 = 0 ;
44496 int res1 = 0 ;
44497 PyObject *swig_obj[1] ;
44498
44499 if (!args) SWIG_fail;
44500 swig_obj[0] = args;
44501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44502 if (!SWIG_IsOK(res1)) {
44503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44504 }
44505 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44506 {
44507 PyThreadState* __tstate = wxPyBeginAllowThreads();
44508 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44509 wxPyEndAllowThreads(__tstate);
44510 if (PyErr_Occurred()) SWIG_fail;
44511 }
44512 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44513 return resultobj;
44514 fail:
44515 return NULL;
44516 }
44517
44518
44519 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44520 PyObject *resultobj = 0;
44521 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44522 bool result;
44523 void *argp1 = 0 ;
44524 int res1 = 0 ;
44525 PyObject *swig_obj[1] ;
44526
44527 if (!args) SWIG_fail;
44528 swig_obj[0] = args;
44529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44530 if (!SWIG_IsOK(res1)) {
44531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44532 }
44533 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44534 {
44535 PyThreadState* __tstate = wxPyBeginAllowThreads();
44536 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44537 wxPyEndAllowThreads(__tstate);
44538 if (PyErr_Occurred()) SWIG_fail;
44539 }
44540 {
44541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44542 }
44543 return resultobj;
44544 fail:
44545 return NULL;
44546 }
44547
44548
44549 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44550 PyObject *resultobj = 0;
44551 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44552 unsigned int arg2 ;
44553 wxString result;
44554 void *argp1 = 0 ;
44555 int res1 = 0 ;
44556 unsigned int val2 ;
44557 int ecode2 = 0 ;
44558 PyObject * obj0 = 0 ;
44559 PyObject * obj1 = 0 ;
44560 char * kwnames[] = {
44561 (char *) "self",(char *) "n", NULL
44562 };
44563
44564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44566 if (!SWIG_IsOK(res1)) {
44567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44568 }
44569 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44570 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44571 if (!SWIG_IsOK(ecode2)) {
44572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44573 }
44574 arg2 = static_cast< unsigned int >(val2);
44575 {
44576 PyThreadState* __tstate = wxPyBeginAllowThreads();
44577 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44578 wxPyEndAllowThreads(__tstate);
44579 if (PyErr_Occurred()) SWIG_fail;
44580 }
44581 {
44582 #if wxUSE_UNICODE
44583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44584 #else
44585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44586 #endif
44587 }
44588 return resultobj;
44589 fail:
44590 return NULL;
44591 }
44592
44593
44594 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44595 PyObject *resultobj = 0;
44596 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44597 wxArrayString result;
44598 void *argp1 = 0 ;
44599 int res1 = 0 ;
44600 PyObject *swig_obj[1] ;
44601
44602 if (!args) SWIG_fail;
44603 swig_obj[0] = args;
44604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44605 if (!SWIG_IsOK(res1)) {
44606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44607 }
44608 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44609 {
44610 PyThreadState* __tstate = wxPyBeginAllowThreads();
44611 result = ((wxItemContainer const *)arg1)->GetStrings();
44612 wxPyEndAllowThreads(__tstate);
44613 if (PyErr_Occurred()) SWIG_fail;
44614 }
44615 {
44616 resultobj = wxArrayString2PyList_helper(result);
44617 }
44618 return resultobj;
44619 fail:
44620 return NULL;
44621 }
44622
44623
44624 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44625 PyObject *resultobj = 0;
44626 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44627 unsigned int arg2 ;
44628 wxString *arg3 = 0 ;
44629 void *argp1 = 0 ;
44630 int res1 = 0 ;
44631 unsigned int val2 ;
44632 int ecode2 = 0 ;
44633 bool temp3 = false ;
44634 PyObject * obj0 = 0 ;
44635 PyObject * obj1 = 0 ;
44636 PyObject * obj2 = 0 ;
44637 char * kwnames[] = {
44638 (char *) "self",(char *) "n",(char *) "s", NULL
44639 };
44640
44641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44643 if (!SWIG_IsOK(res1)) {
44644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44645 }
44646 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44647 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44648 if (!SWIG_IsOK(ecode2)) {
44649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44650 }
44651 arg2 = static_cast< unsigned int >(val2);
44652 {
44653 arg3 = wxString_in_helper(obj2);
44654 if (arg3 == NULL) SWIG_fail;
44655 temp3 = true;
44656 }
44657 {
44658 PyThreadState* __tstate = wxPyBeginAllowThreads();
44659 (arg1)->SetString(arg2,(wxString const &)*arg3);
44660 wxPyEndAllowThreads(__tstate);
44661 if (PyErr_Occurred()) SWIG_fail;
44662 }
44663 resultobj = SWIG_Py_Void();
44664 {
44665 if (temp3)
44666 delete arg3;
44667 }
44668 return resultobj;
44669 fail:
44670 {
44671 if (temp3)
44672 delete arg3;
44673 }
44674 return NULL;
44675 }
44676
44677
44678 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44679 PyObject *resultobj = 0;
44680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44681 wxString *arg2 = 0 ;
44682 int result;
44683 void *argp1 = 0 ;
44684 int res1 = 0 ;
44685 bool temp2 = false ;
44686 PyObject * obj0 = 0 ;
44687 PyObject * obj1 = 0 ;
44688 char * kwnames[] = {
44689 (char *) "self",(char *) "s", NULL
44690 };
44691
44692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44694 if (!SWIG_IsOK(res1)) {
44695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44696 }
44697 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44698 {
44699 arg2 = wxString_in_helper(obj1);
44700 if (arg2 == NULL) SWIG_fail;
44701 temp2 = true;
44702 }
44703 {
44704 PyThreadState* __tstate = wxPyBeginAllowThreads();
44705 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44706 wxPyEndAllowThreads(__tstate);
44707 if (PyErr_Occurred()) SWIG_fail;
44708 }
44709 resultobj = SWIG_From_int(static_cast< int >(result));
44710 {
44711 if (temp2)
44712 delete arg2;
44713 }
44714 return resultobj;
44715 fail:
44716 {
44717 if (temp2)
44718 delete arg2;
44719 }
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44725 PyObject *resultobj = 0;
44726 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44727 int arg2 ;
44728 void *argp1 = 0 ;
44729 int res1 = 0 ;
44730 int val2 ;
44731 int ecode2 = 0 ;
44732 PyObject * obj0 = 0 ;
44733 PyObject * obj1 = 0 ;
44734 char * kwnames[] = {
44735 (char *) "self",(char *) "n", NULL
44736 };
44737
44738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44740 if (!SWIG_IsOK(res1)) {
44741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44742 }
44743 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44744 ecode2 = SWIG_AsVal_int(obj1, &val2);
44745 if (!SWIG_IsOK(ecode2)) {
44746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44747 }
44748 arg2 = static_cast< int >(val2);
44749 {
44750 PyThreadState* __tstate = wxPyBeginAllowThreads();
44751 (arg1)->SetSelection(arg2);
44752 wxPyEndAllowThreads(__tstate);
44753 if (PyErr_Occurred()) SWIG_fail;
44754 }
44755 resultobj = SWIG_Py_Void();
44756 return resultobj;
44757 fail:
44758 return NULL;
44759 }
44760
44761
44762 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44763 PyObject *resultobj = 0;
44764 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44765 int result;
44766 void *argp1 = 0 ;
44767 int res1 = 0 ;
44768 PyObject *swig_obj[1] ;
44769
44770 if (!args) SWIG_fail;
44771 swig_obj[0] = args;
44772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44773 if (!SWIG_IsOK(res1)) {
44774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44775 }
44776 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44777 {
44778 PyThreadState* __tstate = wxPyBeginAllowThreads();
44779 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44780 wxPyEndAllowThreads(__tstate);
44781 if (PyErr_Occurred()) SWIG_fail;
44782 }
44783 resultobj = SWIG_From_int(static_cast< int >(result));
44784 return resultobj;
44785 fail:
44786 return NULL;
44787 }
44788
44789
44790 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44791 PyObject *resultobj = 0;
44792 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44793 wxString *arg2 = 0 ;
44794 bool result;
44795 void *argp1 = 0 ;
44796 int res1 = 0 ;
44797 bool temp2 = false ;
44798 PyObject * obj0 = 0 ;
44799 PyObject * obj1 = 0 ;
44800 char * kwnames[] = {
44801 (char *) "self",(char *) "s", NULL
44802 };
44803
44804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44806 if (!SWIG_IsOK(res1)) {
44807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44808 }
44809 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44810 {
44811 arg2 = wxString_in_helper(obj1);
44812 if (arg2 == NULL) SWIG_fail;
44813 temp2 = true;
44814 }
44815 {
44816 PyThreadState* __tstate = wxPyBeginAllowThreads();
44817 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44818 wxPyEndAllowThreads(__tstate);
44819 if (PyErr_Occurred()) SWIG_fail;
44820 }
44821 {
44822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44823 }
44824 {
44825 if (temp2)
44826 delete arg2;
44827 }
44828 return resultobj;
44829 fail:
44830 {
44831 if (temp2)
44832 delete arg2;
44833 }
44834 return NULL;
44835 }
44836
44837
44838 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44839 PyObject *resultobj = 0;
44840 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44841 wxString result;
44842 void *argp1 = 0 ;
44843 int res1 = 0 ;
44844 PyObject *swig_obj[1] ;
44845
44846 if (!args) SWIG_fail;
44847 swig_obj[0] = args;
44848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44849 if (!SWIG_IsOK(res1)) {
44850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44851 }
44852 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44853 {
44854 PyThreadState* __tstate = wxPyBeginAllowThreads();
44855 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44856 wxPyEndAllowThreads(__tstate);
44857 if (PyErr_Occurred()) SWIG_fail;
44858 }
44859 {
44860 #if wxUSE_UNICODE
44861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44862 #else
44863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44864 #endif
44865 }
44866 return resultobj;
44867 fail:
44868 return NULL;
44869 }
44870
44871
44872 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44873 PyObject *resultobj = 0;
44874 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44875 int arg2 ;
44876 void *argp1 = 0 ;
44877 int res1 = 0 ;
44878 int val2 ;
44879 int ecode2 = 0 ;
44880 PyObject * obj0 = 0 ;
44881 PyObject * obj1 = 0 ;
44882 char * kwnames[] = {
44883 (char *) "self",(char *) "n", NULL
44884 };
44885
44886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44888 if (!SWIG_IsOK(res1)) {
44889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44890 }
44891 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44892 ecode2 = SWIG_AsVal_int(obj1, &val2);
44893 if (!SWIG_IsOK(ecode2)) {
44894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44895 }
44896 arg2 = static_cast< int >(val2);
44897 {
44898 PyThreadState* __tstate = wxPyBeginAllowThreads();
44899 (arg1)->Select(arg2);
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 resultobj = SWIG_Py_Void();
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44911 PyObject *obj;
44912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44913 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44914 return SWIG_Py_Void();
44915 }
44916
44917 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44918 PyObject *obj;
44919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44920 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44921 return SWIG_Py_Void();
44922 }
44923
44924 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44925 PyObject *resultobj = 0;
44926 wxSizerItem *result = 0 ;
44927
44928 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (wxSizerItem *)new wxSizerItem();
44932 wxPyEndAllowThreads(__tstate);
44933 if (PyErr_Occurred()) SWIG_fail;
44934 }
44935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44936 return resultobj;
44937 fail:
44938 return NULL;
44939 }
44940
44941
44942 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44943 PyObject *resultobj = 0;
44944 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44945 void *argp1 = 0 ;
44946 int res1 = 0 ;
44947 PyObject *swig_obj[1] ;
44948
44949 if (!args) SWIG_fail;
44950 swig_obj[0] = args;
44951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44952 if (!SWIG_IsOK(res1)) {
44953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44954 }
44955 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44956 {
44957 PyThreadState* __tstate = wxPyBeginAllowThreads();
44958 delete arg1;
44959
44960 wxPyEndAllowThreads(__tstate);
44961 if (PyErr_Occurred()) SWIG_fail;
44962 }
44963 resultobj = SWIG_Py_Void();
44964 return resultobj;
44965 fail:
44966 return NULL;
44967 }
44968
44969
44970 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44971 PyObject *resultobj = 0;
44972 wxWindow *arg1 = (wxWindow *) 0 ;
44973 int arg2 ;
44974 int arg3 ;
44975 int arg4 ;
44976 PyObject *arg5 = (PyObject *) NULL ;
44977 wxSizerItem *result = 0 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 int val2 ;
44981 int ecode2 = 0 ;
44982 int val3 ;
44983 int ecode3 = 0 ;
44984 int val4 ;
44985 int ecode4 = 0 ;
44986 PyObject * obj0 = 0 ;
44987 PyObject * obj1 = 0 ;
44988 PyObject * obj2 = 0 ;
44989 PyObject * obj3 = 0 ;
44990 PyObject * obj4 = 0 ;
44991 char * kwnames[] = {
44992 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44993 };
44994
44995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44997 if (!SWIG_IsOK(res1)) {
44998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44999 }
45000 arg1 = reinterpret_cast< wxWindow * >(argp1);
45001 ecode2 = SWIG_AsVal_int(obj1, &val2);
45002 if (!SWIG_IsOK(ecode2)) {
45003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45004 }
45005 arg2 = static_cast< int >(val2);
45006 ecode3 = SWIG_AsVal_int(obj2, &val3);
45007 if (!SWIG_IsOK(ecode3)) {
45008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45009 }
45010 arg3 = static_cast< int >(val3);
45011 ecode4 = SWIG_AsVal_int(obj3, &val4);
45012 if (!SWIG_IsOK(ecode4)) {
45013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45014 }
45015 arg4 = static_cast< int >(val4);
45016 if (obj4) {
45017 arg5 = obj4;
45018 }
45019 {
45020 PyThreadState* __tstate = wxPyBeginAllowThreads();
45021 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45022 wxPyEndAllowThreads(__tstate);
45023 if (PyErr_Occurred()) SWIG_fail;
45024 }
45025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45026 return resultobj;
45027 fail:
45028 return NULL;
45029 }
45030
45031
45032 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45033 PyObject *resultobj = 0;
45034 int arg1 ;
45035 int arg2 ;
45036 int arg3 ;
45037 int arg4 ;
45038 int arg5 ;
45039 PyObject *arg6 = (PyObject *) NULL ;
45040 wxSizerItem *result = 0 ;
45041 int val1 ;
45042 int ecode1 = 0 ;
45043 int val2 ;
45044 int ecode2 = 0 ;
45045 int val3 ;
45046 int ecode3 = 0 ;
45047 int val4 ;
45048 int ecode4 = 0 ;
45049 int val5 ;
45050 int ecode5 = 0 ;
45051 PyObject * obj0 = 0 ;
45052 PyObject * obj1 = 0 ;
45053 PyObject * obj2 = 0 ;
45054 PyObject * obj3 = 0 ;
45055 PyObject * obj4 = 0 ;
45056 PyObject * obj5 = 0 ;
45057 char * kwnames[] = {
45058 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45059 };
45060
45061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45062 ecode1 = SWIG_AsVal_int(obj0, &val1);
45063 if (!SWIG_IsOK(ecode1)) {
45064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45065 }
45066 arg1 = static_cast< int >(val1);
45067 ecode2 = SWIG_AsVal_int(obj1, &val2);
45068 if (!SWIG_IsOK(ecode2)) {
45069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45070 }
45071 arg2 = static_cast< int >(val2);
45072 ecode3 = SWIG_AsVal_int(obj2, &val3);
45073 if (!SWIG_IsOK(ecode3)) {
45074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45075 }
45076 arg3 = static_cast< int >(val3);
45077 ecode4 = SWIG_AsVal_int(obj3, &val4);
45078 if (!SWIG_IsOK(ecode4)) {
45079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45080 }
45081 arg4 = static_cast< int >(val4);
45082 ecode5 = SWIG_AsVal_int(obj4, &val5);
45083 if (!SWIG_IsOK(ecode5)) {
45084 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45085 }
45086 arg5 = static_cast< int >(val5);
45087 if (obj5) {
45088 arg6 = obj5;
45089 }
45090 {
45091 PyThreadState* __tstate = wxPyBeginAllowThreads();
45092 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45093 wxPyEndAllowThreads(__tstate);
45094 if (PyErr_Occurred()) SWIG_fail;
45095 }
45096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = 0;
45105 wxSizer *arg1 = (wxSizer *) 0 ;
45106 int arg2 ;
45107 int arg3 ;
45108 int arg4 ;
45109 PyObject *arg5 = (PyObject *) NULL ;
45110 wxSizerItem *result = 0 ;
45111 int res1 = 0 ;
45112 int val2 ;
45113 int ecode2 = 0 ;
45114 int val3 ;
45115 int ecode3 = 0 ;
45116 int val4 ;
45117 int ecode4 = 0 ;
45118 PyObject * obj0 = 0 ;
45119 PyObject * obj1 = 0 ;
45120 PyObject * obj2 = 0 ;
45121 PyObject * obj3 = 0 ;
45122 PyObject * obj4 = 0 ;
45123 char * kwnames[] = {
45124 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45125 };
45126
45127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45128 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45129 if (!SWIG_IsOK(res1)) {
45130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45131 }
45132 ecode2 = SWIG_AsVal_int(obj1, &val2);
45133 if (!SWIG_IsOK(ecode2)) {
45134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45135 }
45136 arg2 = static_cast< int >(val2);
45137 ecode3 = SWIG_AsVal_int(obj2, &val3);
45138 if (!SWIG_IsOK(ecode3)) {
45139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45140 }
45141 arg3 = static_cast< int >(val3);
45142 ecode4 = SWIG_AsVal_int(obj3, &val4);
45143 if (!SWIG_IsOK(ecode4)) {
45144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45145 }
45146 arg4 = static_cast< int >(val4);
45147 if (obj4) {
45148 arg5 = obj4;
45149 }
45150 {
45151 PyThreadState* __tstate = wxPyBeginAllowThreads();
45152 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45153 wxPyEndAllowThreads(__tstate);
45154 if (PyErr_Occurred()) SWIG_fail;
45155 }
45156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45157 return resultobj;
45158 fail:
45159 return NULL;
45160 }
45161
45162
45163 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45164 PyObject *resultobj = 0;
45165 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45166 void *argp1 = 0 ;
45167 int res1 = 0 ;
45168 PyObject *swig_obj[1] ;
45169
45170 if (!args) SWIG_fail;
45171 swig_obj[0] = args;
45172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45173 if (!SWIG_IsOK(res1)) {
45174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45175 }
45176 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45177 {
45178 PyThreadState* __tstate = wxPyBeginAllowThreads();
45179 (arg1)->DeleteWindows();
45180 wxPyEndAllowThreads(__tstate);
45181 if (PyErr_Occurred()) SWIG_fail;
45182 }
45183 resultobj = SWIG_Py_Void();
45184 return resultobj;
45185 fail:
45186 return NULL;
45187 }
45188
45189
45190 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45191 PyObject *resultobj = 0;
45192 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45193 void *argp1 = 0 ;
45194 int res1 = 0 ;
45195 PyObject *swig_obj[1] ;
45196
45197 if (!args) SWIG_fail;
45198 swig_obj[0] = args;
45199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45202 }
45203 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45204 {
45205 PyThreadState* __tstate = wxPyBeginAllowThreads();
45206 (arg1)->DetachSizer();
45207 wxPyEndAllowThreads(__tstate);
45208 if (PyErr_Occurred()) SWIG_fail;
45209 }
45210 resultobj = SWIG_Py_Void();
45211 return resultobj;
45212 fail:
45213 return NULL;
45214 }
45215
45216
45217 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45218 PyObject *resultobj = 0;
45219 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45220 wxSize result;
45221 void *argp1 = 0 ;
45222 int res1 = 0 ;
45223 PyObject *swig_obj[1] ;
45224
45225 if (!args) SWIG_fail;
45226 swig_obj[0] = args;
45227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45228 if (!SWIG_IsOK(res1)) {
45229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45230 }
45231 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45232 {
45233 PyThreadState* __tstate = wxPyBeginAllowThreads();
45234 result = (arg1)->GetSize();
45235 wxPyEndAllowThreads(__tstate);
45236 if (PyErr_Occurred()) SWIG_fail;
45237 }
45238 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45239 return resultobj;
45240 fail:
45241 return NULL;
45242 }
45243
45244
45245 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45246 PyObject *resultobj = 0;
45247 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45248 wxSize result;
45249 void *argp1 = 0 ;
45250 int res1 = 0 ;
45251 PyObject *swig_obj[1] ;
45252
45253 if (!args) SWIG_fail;
45254 swig_obj[0] = args;
45255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45256 if (!SWIG_IsOK(res1)) {
45257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45258 }
45259 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45260 {
45261 PyThreadState* __tstate = wxPyBeginAllowThreads();
45262 result = (arg1)->CalcMin();
45263 wxPyEndAllowThreads(__tstate);
45264 if (PyErr_Occurred()) SWIG_fail;
45265 }
45266 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45267 return resultobj;
45268 fail:
45269 return NULL;
45270 }
45271
45272
45273 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45274 PyObject *resultobj = 0;
45275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45276 wxPoint *arg2 = 0 ;
45277 wxSize *arg3 = 0 ;
45278 void *argp1 = 0 ;
45279 int res1 = 0 ;
45280 wxPoint temp2 ;
45281 wxSize temp3 ;
45282 PyObject * obj0 = 0 ;
45283 PyObject * obj1 = 0 ;
45284 PyObject * obj2 = 0 ;
45285 char * kwnames[] = {
45286 (char *) "self",(char *) "pos",(char *) "size", NULL
45287 };
45288
45289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45291 if (!SWIG_IsOK(res1)) {
45292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45293 }
45294 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45295 {
45296 arg2 = &temp2;
45297 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45298 }
45299 {
45300 arg3 = &temp3;
45301 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45302 }
45303 {
45304 PyThreadState* __tstate = wxPyBeginAllowThreads();
45305 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45306 wxPyEndAllowThreads(__tstate);
45307 if (PyErr_Occurred()) SWIG_fail;
45308 }
45309 resultobj = SWIG_Py_Void();
45310 return resultobj;
45311 fail:
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45317 PyObject *resultobj = 0;
45318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45319 wxSize result;
45320 void *argp1 = 0 ;
45321 int res1 = 0 ;
45322 PyObject *swig_obj[1] ;
45323
45324 if (!args) SWIG_fail;
45325 swig_obj[0] = args;
45326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45327 if (!SWIG_IsOK(res1)) {
45328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45329 }
45330 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45331 {
45332 PyThreadState* __tstate = wxPyBeginAllowThreads();
45333 result = (arg1)->GetMinSize();
45334 wxPyEndAllowThreads(__tstate);
45335 if (PyErr_Occurred()) SWIG_fail;
45336 }
45337 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45338 return resultobj;
45339 fail:
45340 return NULL;
45341 }
45342
45343
45344 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45345 PyObject *resultobj = 0;
45346 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45347 wxSize result;
45348 void *argp1 = 0 ;
45349 int res1 = 0 ;
45350 PyObject *swig_obj[1] ;
45351
45352 if (!args) SWIG_fail;
45353 swig_obj[0] = args;
45354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45355 if (!SWIG_IsOK(res1)) {
45356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45357 }
45358 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45359 {
45360 PyThreadState* __tstate = wxPyBeginAllowThreads();
45361 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45362 wxPyEndAllowThreads(__tstate);
45363 if (PyErr_Occurred()) SWIG_fail;
45364 }
45365 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45366 return resultobj;
45367 fail:
45368 return NULL;
45369 }
45370
45371
45372 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45373 PyObject *resultobj = 0;
45374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45375 int arg2 ;
45376 int arg3 ;
45377 void *argp1 = 0 ;
45378 int res1 = 0 ;
45379 int val2 ;
45380 int ecode2 = 0 ;
45381 int val3 ;
45382 int ecode3 = 0 ;
45383 PyObject * obj0 = 0 ;
45384 PyObject * obj1 = 0 ;
45385 PyObject * obj2 = 0 ;
45386 char * kwnames[] = {
45387 (char *) "self",(char *) "x",(char *) "y", NULL
45388 };
45389
45390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45392 if (!SWIG_IsOK(res1)) {
45393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45394 }
45395 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45396 ecode2 = SWIG_AsVal_int(obj1, &val2);
45397 if (!SWIG_IsOK(ecode2)) {
45398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45399 }
45400 arg2 = static_cast< int >(val2);
45401 ecode3 = SWIG_AsVal_int(obj2, &val3);
45402 if (!SWIG_IsOK(ecode3)) {
45403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45404 }
45405 arg3 = static_cast< int >(val3);
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 (arg1)->SetInitSize(arg2,arg3);
45409 wxPyEndAllowThreads(__tstate);
45410 if (PyErr_Occurred()) SWIG_fail;
45411 }
45412 resultobj = SWIG_Py_Void();
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45420 PyObject *resultobj = 0;
45421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45422 int arg2 ;
45423 int arg3 ;
45424 void *argp1 = 0 ;
45425 int res1 = 0 ;
45426 int val2 ;
45427 int ecode2 = 0 ;
45428 int val3 ;
45429 int ecode3 = 0 ;
45430 PyObject * obj0 = 0 ;
45431 PyObject * obj1 = 0 ;
45432 PyObject * obj2 = 0 ;
45433 char * kwnames[] = {
45434 (char *) "self",(char *) "width",(char *) "height", NULL
45435 };
45436
45437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45439 if (!SWIG_IsOK(res1)) {
45440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45441 }
45442 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45443 ecode2 = SWIG_AsVal_int(obj1, &val2);
45444 if (!SWIG_IsOK(ecode2)) {
45445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45446 }
45447 arg2 = static_cast< int >(val2);
45448 ecode3 = SWIG_AsVal_int(obj2, &val3);
45449 if (!SWIG_IsOK(ecode3)) {
45450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45451 }
45452 arg3 = static_cast< int >(val3);
45453 {
45454 PyThreadState* __tstate = wxPyBeginAllowThreads();
45455 (arg1)->SetRatio(arg2,arg3);
45456 wxPyEndAllowThreads(__tstate);
45457 if (PyErr_Occurred()) SWIG_fail;
45458 }
45459 resultobj = SWIG_Py_Void();
45460 return resultobj;
45461 fail:
45462 return NULL;
45463 }
45464
45465
45466 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45467 PyObject *resultobj = 0;
45468 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45469 wxSize *arg2 = 0 ;
45470 void *argp1 = 0 ;
45471 int res1 = 0 ;
45472 wxSize temp2 ;
45473 PyObject * obj0 = 0 ;
45474 PyObject * obj1 = 0 ;
45475 char * kwnames[] = {
45476 (char *) "self",(char *) "size", NULL
45477 };
45478
45479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45481 if (!SWIG_IsOK(res1)) {
45482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45483 }
45484 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45485 {
45486 arg2 = &temp2;
45487 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45488 }
45489 {
45490 PyThreadState* __tstate = wxPyBeginAllowThreads();
45491 (arg1)->SetRatio((wxSize const &)*arg2);
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 resultobj = SWIG_Py_Void();
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45503 PyObject *resultobj = 0;
45504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45505 float arg2 ;
45506 void *argp1 = 0 ;
45507 int res1 = 0 ;
45508 float val2 ;
45509 int ecode2 = 0 ;
45510 PyObject * obj0 = 0 ;
45511 PyObject * obj1 = 0 ;
45512 char * kwnames[] = {
45513 (char *) "self",(char *) "ratio", NULL
45514 };
45515
45516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45518 if (!SWIG_IsOK(res1)) {
45519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45520 }
45521 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45522 ecode2 = SWIG_AsVal_float(obj1, &val2);
45523 if (!SWIG_IsOK(ecode2)) {
45524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45525 }
45526 arg2 = static_cast< float >(val2);
45527 {
45528 PyThreadState* __tstate = wxPyBeginAllowThreads();
45529 (arg1)->SetRatio(arg2);
45530 wxPyEndAllowThreads(__tstate);
45531 if (PyErr_Occurred()) SWIG_fail;
45532 }
45533 resultobj = SWIG_Py_Void();
45534 return resultobj;
45535 fail:
45536 return NULL;
45537 }
45538
45539
45540 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45541 PyObject *resultobj = 0;
45542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45543 float result;
45544 void *argp1 = 0 ;
45545 int res1 = 0 ;
45546 PyObject *swig_obj[1] ;
45547
45548 if (!args) SWIG_fail;
45549 swig_obj[0] = args;
45550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45551 if (!SWIG_IsOK(res1)) {
45552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45553 }
45554 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45555 {
45556 PyThreadState* __tstate = wxPyBeginAllowThreads();
45557 result = (float)(arg1)->GetRatio();
45558 wxPyEndAllowThreads(__tstate);
45559 if (PyErr_Occurred()) SWIG_fail;
45560 }
45561 resultobj = SWIG_From_float(static_cast< float >(result));
45562 return resultobj;
45563 fail:
45564 return NULL;
45565 }
45566
45567
45568 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45569 PyObject *resultobj = 0;
45570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45571 wxRect result;
45572 void *argp1 = 0 ;
45573 int res1 = 0 ;
45574 PyObject *swig_obj[1] ;
45575
45576 if (!args) SWIG_fail;
45577 swig_obj[0] = args;
45578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45579 if (!SWIG_IsOK(res1)) {
45580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45581 }
45582 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45583 {
45584 PyThreadState* __tstate = wxPyBeginAllowThreads();
45585 result = (arg1)->GetRect();
45586 wxPyEndAllowThreads(__tstate);
45587 if (PyErr_Occurred()) SWIG_fail;
45588 }
45589 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45590 return resultobj;
45591 fail:
45592 return NULL;
45593 }
45594
45595
45596 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45597 PyObject *resultobj = 0;
45598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45599 bool result;
45600 void *argp1 = 0 ;
45601 int res1 = 0 ;
45602 PyObject *swig_obj[1] ;
45603
45604 if (!args) SWIG_fail;
45605 swig_obj[0] = args;
45606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45607 if (!SWIG_IsOK(res1)) {
45608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45609 }
45610 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45611 {
45612 PyThreadState* __tstate = wxPyBeginAllowThreads();
45613 result = (bool)(arg1)->IsWindow();
45614 wxPyEndAllowThreads(__tstate);
45615 if (PyErr_Occurred()) SWIG_fail;
45616 }
45617 {
45618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45619 }
45620 return resultobj;
45621 fail:
45622 return NULL;
45623 }
45624
45625
45626 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45627 PyObject *resultobj = 0;
45628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45629 bool result;
45630 void *argp1 = 0 ;
45631 int res1 = 0 ;
45632 PyObject *swig_obj[1] ;
45633
45634 if (!args) SWIG_fail;
45635 swig_obj[0] = args;
45636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45637 if (!SWIG_IsOK(res1)) {
45638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45639 }
45640 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45641 {
45642 PyThreadState* __tstate = wxPyBeginAllowThreads();
45643 result = (bool)(arg1)->IsSizer();
45644 wxPyEndAllowThreads(__tstate);
45645 if (PyErr_Occurred()) SWIG_fail;
45646 }
45647 {
45648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45649 }
45650 return resultobj;
45651 fail:
45652 return NULL;
45653 }
45654
45655
45656 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45657 PyObject *resultobj = 0;
45658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45659 bool result;
45660 void *argp1 = 0 ;
45661 int res1 = 0 ;
45662 PyObject *swig_obj[1] ;
45663
45664 if (!args) SWIG_fail;
45665 swig_obj[0] = args;
45666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45667 if (!SWIG_IsOK(res1)) {
45668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45669 }
45670 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45671 {
45672 PyThreadState* __tstate = wxPyBeginAllowThreads();
45673 result = (bool)(arg1)->IsSpacer();
45674 wxPyEndAllowThreads(__tstate);
45675 if (PyErr_Occurred()) SWIG_fail;
45676 }
45677 {
45678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45679 }
45680 return resultobj;
45681 fail:
45682 return NULL;
45683 }
45684
45685
45686 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45687 PyObject *resultobj = 0;
45688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45689 int arg2 ;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 int val2 ;
45693 int ecode2 = 0 ;
45694 PyObject * obj0 = 0 ;
45695 PyObject * obj1 = 0 ;
45696 char * kwnames[] = {
45697 (char *) "self",(char *) "proportion", NULL
45698 };
45699
45700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45702 if (!SWIG_IsOK(res1)) {
45703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45704 }
45705 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45706 ecode2 = SWIG_AsVal_int(obj1, &val2);
45707 if (!SWIG_IsOK(ecode2)) {
45708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45709 }
45710 arg2 = static_cast< int >(val2);
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 (arg1)->SetProportion(arg2);
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 resultobj = SWIG_Py_Void();
45718 return resultobj;
45719 fail:
45720 return NULL;
45721 }
45722
45723
45724 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45725 PyObject *resultobj = 0;
45726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45727 int result;
45728 void *argp1 = 0 ;
45729 int res1 = 0 ;
45730 PyObject *swig_obj[1] ;
45731
45732 if (!args) SWIG_fail;
45733 swig_obj[0] = args;
45734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45735 if (!SWIG_IsOK(res1)) {
45736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45737 }
45738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 result = (int)(arg1)->GetProportion();
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 resultobj = SWIG_From_int(static_cast< int >(result));
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45755 int arg2 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 int val2 ;
45759 int ecode2 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "flag", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45770 }
45771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45772 ecode2 = SWIG_AsVal_int(obj1, &val2);
45773 if (!SWIG_IsOK(ecode2)) {
45774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45775 }
45776 arg2 = static_cast< int >(val2);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 (arg1)->SetFlag(arg2);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = SWIG_Py_Void();
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45791 PyObject *resultobj = 0;
45792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45793 int result;
45794 void *argp1 = 0 ;
45795 int res1 = 0 ;
45796 PyObject *swig_obj[1] ;
45797
45798 if (!args) SWIG_fail;
45799 swig_obj[0] = args;
45800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45801 if (!SWIG_IsOK(res1)) {
45802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45803 }
45804 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45805 {
45806 PyThreadState* __tstate = wxPyBeginAllowThreads();
45807 result = (int)(arg1)->GetFlag();
45808 wxPyEndAllowThreads(__tstate);
45809 if (PyErr_Occurred()) SWIG_fail;
45810 }
45811 resultobj = SWIG_From_int(static_cast< int >(result));
45812 return resultobj;
45813 fail:
45814 return NULL;
45815 }
45816
45817
45818 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45819 PyObject *resultobj = 0;
45820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45821 int arg2 ;
45822 void *argp1 = 0 ;
45823 int res1 = 0 ;
45824 int val2 ;
45825 int ecode2 = 0 ;
45826 PyObject * obj0 = 0 ;
45827 PyObject * obj1 = 0 ;
45828 char * kwnames[] = {
45829 (char *) "self",(char *) "border", NULL
45830 };
45831
45832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45834 if (!SWIG_IsOK(res1)) {
45835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45836 }
45837 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45838 ecode2 = SWIG_AsVal_int(obj1, &val2);
45839 if (!SWIG_IsOK(ecode2)) {
45840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45841 }
45842 arg2 = static_cast< int >(val2);
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 (arg1)->SetBorder(arg2);
45846 wxPyEndAllowThreads(__tstate);
45847 if (PyErr_Occurred()) SWIG_fail;
45848 }
45849 resultobj = SWIG_Py_Void();
45850 return resultobj;
45851 fail:
45852 return NULL;
45853 }
45854
45855
45856 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45857 PyObject *resultobj = 0;
45858 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45859 int result;
45860 void *argp1 = 0 ;
45861 int res1 = 0 ;
45862 PyObject *swig_obj[1] ;
45863
45864 if (!args) SWIG_fail;
45865 swig_obj[0] = args;
45866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45867 if (!SWIG_IsOK(res1)) {
45868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45869 }
45870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45871 {
45872 PyThreadState* __tstate = wxPyBeginAllowThreads();
45873 result = (int)(arg1)->GetBorder();
45874 wxPyEndAllowThreads(__tstate);
45875 if (PyErr_Occurred()) SWIG_fail;
45876 }
45877 resultobj = SWIG_From_int(static_cast< int >(result));
45878 return resultobj;
45879 fail:
45880 return NULL;
45881 }
45882
45883
45884 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45885 PyObject *resultobj = 0;
45886 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45887 wxWindow *result = 0 ;
45888 void *argp1 = 0 ;
45889 int res1 = 0 ;
45890 PyObject *swig_obj[1] ;
45891
45892 if (!args) SWIG_fail;
45893 swig_obj[0] = args;
45894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45895 if (!SWIG_IsOK(res1)) {
45896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45897 }
45898 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45899 {
45900 PyThreadState* __tstate = wxPyBeginAllowThreads();
45901 result = (wxWindow *)(arg1)->GetWindow();
45902 wxPyEndAllowThreads(__tstate);
45903 if (PyErr_Occurred()) SWIG_fail;
45904 }
45905 {
45906 resultobj = wxPyMake_wxObject(result, 0);
45907 }
45908 return resultobj;
45909 fail:
45910 return NULL;
45911 }
45912
45913
45914 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45915 PyObject *resultobj = 0;
45916 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45917 wxWindow *arg2 = (wxWindow *) 0 ;
45918 void *argp1 = 0 ;
45919 int res1 = 0 ;
45920 void *argp2 = 0 ;
45921 int res2 = 0 ;
45922 PyObject * obj0 = 0 ;
45923 PyObject * obj1 = 0 ;
45924 char * kwnames[] = {
45925 (char *) "self",(char *) "window", NULL
45926 };
45927
45928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45930 if (!SWIG_IsOK(res1)) {
45931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45932 }
45933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45935 if (!SWIG_IsOK(res2)) {
45936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45937 }
45938 arg2 = reinterpret_cast< wxWindow * >(argp2);
45939 {
45940 PyThreadState* __tstate = wxPyBeginAllowThreads();
45941 (arg1)->SetWindow(arg2);
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 resultobj = SWIG_Py_Void();
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45953 PyObject *resultobj = 0;
45954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45955 wxSizer *result = 0 ;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 PyObject *swig_obj[1] ;
45959
45960 if (!args) SWIG_fail;
45961 swig_obj[0] = args;
45962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45963 if (!SWIG_IsOK(res1)) {
45964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45965 }
45966 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45967 {
45968 PyThreadState* __tstate = wxPyBeginAllowThreads();
45969 result = (wxSizer *)(arg1)->GetSizer();
45970 wxPyEndAllowThreads(__tstate);
45971 if (PyErr_Occurred()) SWIG_fail;
45972 }
45973 {
45974 resultobj = wxPyMake_wxObject(result, (bool)0);
45975 }
45976 return resultobj;
45977 fail:
45978 return NULL;
45979 }
45980
45981
45982 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45983 PyObject *resultobj = 0;
45984 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45985 wxSizer *arg2 = (wxSizer *) 0 ;
45986 void *argp1 = 0 ;
45987 int res1 = 0 ;
45988 int res2 = 0 ;
45989 PyObject * obj0 = 0 ;
45990 PyObject * obj1 = 0 ;
45991 char * kwnames[] = {
45992 (char *) "self",(char *) "sizer", NULL
45993 };
45994
45995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45997 if (!SWIG_IsOK(res1)) {
45998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45999 }
46000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46001 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46002 if (!SWIG_IsOK(res2)) {
46003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46004 }
46005 {
46006 PyThreadState* __tstate = wxPyBeginAllowThreads();
46007 (arg1)->SetSizer(arg2);
46008 wxPyEndAllowThreads(__tstate);
46009 if (PyErr_Occurred()) SWIG_fail;
46010 }
46011 resultobj = SWIG_Py_Void();
46012 return resultobj;
46013 fail:
46014 return NULL;
46015 }
46016
46017
46018 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46019 PyObject *resultobj = 0;
46020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46021 wxSize *result = 0 ;
46022 void *argp1 = 0 ;
46023 int res1 = 0 ;
46024 PyObject *swig_obj[1] ;
46025
46026 if (!args) SWIG_fail;
46027 swig_obj[0] = args;
46028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46029 if (!SWIG_IsOK(res1)) {
46030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46031 }
46032 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46033 {
46034 PyThreadState* __tstate = wxPyBeginAllowThreads();
46035 {
46036 wxSize const &_result_ref = (arg1)->GetSpacer();
46037 result = (wxSize *) &_result_ref;
46038 }
46039 wxPyEndAllowThreads(__tstate);
46040 if (PyErr_Occurred()) SWIG_fail;
46041 }
46042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46043 return resultobj;
46044 fail:
46045 return NULL;
46046 }
46047
46048
46049 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46050 PyObject *resultobj = 0;
46051 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46052 wxSize *arg2 = 0 ;
46053 void *argp1 = 0 ;
46054 int res1 = 0 ;
46055 wxSize temp2 ;
46056 PyObject * obj0 = 0 ;
46057 PyObject * obj1 = 0 ;
46058 char * kwnames[] = {
46059 (char *) "self",(char *) "size", NULL
46060 };
46061
46062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46064 if (!SWIG_IsOK(res1)) {
46065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46066 }
46067 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46068 {
46069 arg2 = &temp2;
46070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46071 }
46072 {
46073 PyThreadState* __tstate = wxPyBeginAllowThreads();
46074 (arg1)->SetSpacer((wxSize const &)*arg2);
46075 wxPyEndAllowThreads(__tstate);
46076 if (PyErr_Occurred()) SWIG_fail;
46077 }
46078 resultobj = SWIG_Py_Void();
46079 return resultobj;
46080 fail:
46081 return NULL;
46082 }
46083
46084
46085 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46086 PyObject *resultobj = 0;
46087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46088 bool arg2 ;
46089 void *argp1 = 0 ;
46090 int res1 = 0 ;
46091 bool val2 ;
46092 int ecode2 = 0 ;
46093 PyObject * obj0 = 0 ;
46094 PyObject * obj1 = 0 ;
46095 char * kwnames[] = {
46096 (char *) "self",(char *) "show", NULL
46097 };
46098
46099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46101 if (!SWIG_IsOK(res1)) {
46102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46103 }
46104 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46105 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46106 if (!SWIG_IsOK(ecode2)) {
46107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46108 }
46109 arg2 = static_cast< bool >(val2);
46110 {
46111 PyThreadState* __tstate = wxPyBeginAllowThreads();
46112 (arg1)->Show(arg2);
46113 wxPyEndAllowThreads(__tstate);
46114 if (PyErr_Occurred()) SWIG_fail;
46115 }
46116 resultobj = SWIG_Py_Void();
46117 return resultobj;
46118 fail:
46119 return NULL;
46120 }
46121
46122
46123 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46124 PyObject *resultobj = 0;
46125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46126 bool result;
46127 void *argp1 = 0 ;
46128 int res1 = 0 ;
46129 PyObject *swig_obj[1] ;
46130
46131 if (!args) SWIG_fail;
46132 swig_obj[0] = args;
46133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46134 if (!SWIG_IsOK(res1)) {
46135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46136 }
46137 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46138 {
46139 PyThreadState* __tstate = wxPyBeginAllowThreads();
46140 result = (bool)(arg1)->IsShown();
46141 wxPyEndAllowThreads(__tstate);
46142 if (PyErr_Occurred()) SWIG_fail;
46143 }
46144 {
46145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46146 }
46147 return resultobj;
46148 fail:
46149 return NULL;
46150 }
46151
46152
46153 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46154 PyObject *resultobj = 0;
46155 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46156 wxPoint result;
46157 void *argp1 = 0 ;
46158 int res1 = 0 ;
46159 PyObject *swig_obj[1] ;
46160
46161 if (!args) SWIG_fail;
46162 swig_obj[0] = args;
46163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46164 if (!SWIG_IsOK(res1)) {
46165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46166 }
46167 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46168 {
46169 PyThreadState* __tstate = wxPyBeginAllowThreads();
46170 result = (arg1)->GetPosition();
46171 wxPyEndAllowThreads(__tstate);
46172 if (PyErr_Occurred()) SWIG_fail;
46173 }
46174 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46175 return resultobj;
46176 fail:
46177 return NULL;
46178 }
46179
46180
46181 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46182 PyObject *resultobj = 0;
46183 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46184 PyObject *result = 0 ;
46185 void *argp1 = 0 ;
46186 int res1 = 0 ;
46187 PyObject *swig_obj[1] ;
46188
46189 if (!args) SWIG_fail;
46190 swig_obj[0] = args;
46191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46192 if (!SWIG_IsOK(res1)) {
46193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46194 }
46195 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46196 {
46197 PyThreadState* __tstate = wxPyBeginAllowThreads();
46198 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46199 wxPyEndAllowThreads(__tstate);
46200 if (PyErr_Occurred()) SWIG_fail;
46201 }
46202 resultobj = result;
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46210 PyObject *resultobj = 0;
46211 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46212 PyObject *arg2 = (PyObject *) 0 ;
46213 void *argp1 = 0 ;
46214 int res1 = 0 ;
46215 PyObject * obj0 = 0 ;
46216 PyObject * obj1 = 0 ;
46217 char * kwnames[] = {
46218 (char *) "self",(char *) "userData", NULL
46219 };
46220
46221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46223 if (!SWIG_IsOK(res1)) {
46224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46225 }
46226 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46227 arg2 = obj1;
46228 {
46229 PyThreadState* __tstate = wxPyBeginAllowThreads();
46230 wxSizerItem_SetUserData(arg1,arg2);
46231 wxPyEndAllowThreads(__tstate);
46232 if (PyErr_Occurred()) SWIG_fail;
46233 }
46234 resultobj = SWIG_Py_Void();
46235 return resultobj;
46236 fail:
46237 return NULL;
46238 }
46239
46240
46241 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46242 PyObject *obj;
46243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46244 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46245 return SWIG_Py_Void();
46246 }
46247
46248 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46249 return SWIG_Python_InitShadowInstance(args);
46250 }
46251
46252 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46253 PyObject *resultobj = 0;
46254 wxSizer *arg1 = (wxSizer *) 0 ;
46255 void *argp1 = 0 ;
46256 int res1 = 0 ;
46257 PyObject *swig_obj[1] ;
46258
46259 if (!args) SWIG_fail;
46260 swig_obj[0] = args;
46261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46262 if (!SWIG_IsOK(res1)) {
46263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46264 }
46265 arg1 = reinterpret_cast< wxSizer * >(argp1);
46266 {
46267 PyThreadState* __tstate = wxPyBeginAllowThreads();
46268 delete arg1;
46269
46270 wxPyEndAllowThreads(__tstate);
46271 if (PyErr_Occurred()) SWIG_fail;
46272 }
46273 resultobj = SWIG_Py_Void();
46274 return resultobj;
46275 fail:
46276 return NULL;
46277 }
46278
46279
46280 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46281 PyObject *resultobj = 0;
46282 wxSizer *arg1 = (wxSizer *) 0 ;
46283 PyObject *arg2 = (PyObject *) 0 ;
46284 void *argp1 = 0 ;
46285 int res1 = 0 ;
46286 PyObject * obj0 = 0 ;
46287 PyObject * obj1 = 0 ;
46288 char * kwnames[] = {
46289 (char *) "self",(char *) "_self", NULL
46290 };
46291
46292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46294 if (!SWIG_IsOK(res1)) {
46295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46296 }
46297 arg1 = reinterpret_cast< wxSizer * >(argp1);
46298 arg2 = obj1;
46299 {
46300 PyThreadState* __tstate = wxPyBeginAllowThreads();
46301 wxSizer__setOORInfo(arg1,arg2);
46302 wxPyEndAllowThreads(__tstate);
46303 if (PyErr_Occurred()) SWIG_fail;
46304 }
46305 resultobj = SWIG_Py_Void();
46306 return resultobj;
46307 fail:
46308 return NULL;
46309 }
46310
46311
46312 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46313 PyObject *resultobj = 0;
46314 wxSizer *arg1 = (wxSizer *) 0 ;
46315 PyObject *arg2 = (PyObject *) 0 ;
46316 int arg3 = (int) 0 ;
46317 int arg4 = (int) 0 ;
46318 int arg5 = (int) 0 ;
46319 PyObject *arg6 = (PyObject *) NULL ;
46320 wxSizerItem *result = 0 ;
46321 void *argp1 = 0 ;
46322 int res1 = 0 ;
46323 int val3 ;
46324 int ecode3 = 0 ;
46325 int val4 ;
46326 int ecode4 = 0 ;
46327 int val5 ;
46328 int ecode5 = 0 ;
46329 PyObject * obj0 = 0 ;
46330 PyObject * obj1 = 0 ;
46331 PyObject * obj2 = 0 ;
46332 PyObject * obj3 = 0 ;
46333 PyObject * obj4 = 0 ;
46334 PyObject * obj5 = 0 ;
46335 char * kwnames[] = {
46336 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46337 };
46338
46339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46341 if (!SWIG_IsOK(res1)) {
46342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46343 }
46344 arg1 = reinterpret_cast< wxSizer * >(argp1);
46345 arg2 = obj1;
46346 if (obj2) {
46347 ecode3 = SWIG_AsVal_int(obj2, &val3);
46348 if (!SWIG_IsOK(ecode3)) {
46349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46350 }
46351 arg3 = static_cast< int >(val3);
46352 }
46353 if (obj3) {
46354 ecode4 = SWIG_AsVal_int(obj3, &val4);
46355 if (!SWIG_IsOK(ecode4)) {
46356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46357 }
46358 arg4 = static_cast< int >(val4);
46359 }
46360 if (obj4) {
46361 ecode5 = SWIG_AsVal_int(obj4, &val5);
46362 if (!SWIG_IsOK(ecode5)) {
46363 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46364 }
46365 arg5 = static_cast< int >(val5);
46366 }
46367 if (obj5) {
46368 arg6 = obj5;
46369 }
46370 {
46371 PyThreadState* __tstate = wxPyBeginAllowThreads();
46372 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46373 wxPyEndAllowThreads(__tstate);
46374 if (PyErr_Occurred()) SWIG_fail;
46375 }
46376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46377 return resultobj;
46378 fail:
46379 return NULL;
46380 }
46381
46382
46383 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46384 PyObject *resultobj = 0;
46385 wxSizer *arg1 = (wxSizer *) 0 ;
46386 int arg2 ;
46387 PyObject *arg3 = (PyObject *) 0 ;
46388 int arg4 = (int) 0 ;
46389 int arg5 = (int) 0 ;
46390 int arg6 = (int) 0 ;
46391 PyObject *arg7 = (PyObject *) NULL ;
46392 wxSizerItem *result = 0 ;
46393 void *argp1 = 0 ;
46394 int res1 = 0 ;
46395 int val2 ;
46396 int ecode2 = 0 ;
46397 int val4 ;
46398 int ecode4 = 0 ;
46399 int val5 ;
46400 int ecode5 = 0 ;
46401 int val6 ;
46402 int ecode6 = 0 ;
46403 PyObject * obj0 = 0 ;
46404 PyObject * obj1 = 0 ;
46405 PyObject * obj2 = 0 ;
46406 PyObject * obj3 = 0 ;
46407 PyObject * obj4 = 0 ;
46408 PyObject * obj5 = 0 ;
46409 PyObject * obj6 = 0 ;
46410 char * kwnames[] = {
46411 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46412 };
46413
46414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46416 if (!SWIG_IsOK(res1)) {
46417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46418 }
46419 arg1 = reinterpret_cast< wxSizer * >(argp1);
46420 ecode2 = SWIG_AsVal_int(obj1, &val2);
46421 if (!SWIG_IsOK(ecode2)) {
46422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46423 }
46424 arg2 = static_cast< int >(val2);
46425 arg3 = obj2;
46426 if (obj3) {
46427 ecode4 = SWIG_AsVal_int(obj3, &val4);
46428 if (!SWIG_IsOK(ecode4)) {
46429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46430 }
46431 arg4 = static_cast< int >(val4);
46432 }
46433 if (obj4) {
46434 ecode5 = SWIG_AsVal_int(obj4, &val5);
46435 if (!SWIG_IsOK(ecode5)) {
46436 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46437 }
46438 arg5 = static_cast< int >(val5);
46439 }
46440 if (obj5) {
46441 ecode6 = SWIG_AsVal_int(obj5, &val6);
46442 if (!SWIG_IsOK(ecode6)) {
46443 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46444 }
46445 arg6 = static_cast< int >(val6);
46446 }
46447 if (obj6) {
46448 arg7 = obj6;
46449 }
46450 {
46451 PyThreadState* __tstate = wxPyBeginAllowThreads();
46452 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46453 wxPyEndAllowThreads(__tstate);
46454 if (PyErr_Occurred()) SWIG_fail;
46455 }
46456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46457 return resultobj;
46458 fail:
46459 return NULL;
46460 }
46461
46462
46463 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46464 PyObject *resultobj = 0;
46465 wxSizer *arg1 = (wxSizer *) 0 ;
46466 PyObject *arg2 = (PyObject *) 0 ;
46467 int arg3 = (int) 0 ;
46468 int arg4 = (int) 0 ;
46469 int arg5 = (int) 0 ;
46470 PyObject *arg6 = (PyObject *) NULL ;
46471 wxSizerItem *result = 0 ;
46472 void *argp1 = 0 ;
46473 int res1 = 0 ;
46474 int val3 ;
46475 int ecode3 = 0 ;
46476 int val4 ;
46477 int ecode4 = 0 ;
46478 int val5 ;
46479 int ecode5 = 0 ;
46480 PyObject * obj0 = 0 ;
46481 PyObject * obj1 = 0 ;
46482 PyObject * obj2 = 0 ;
46483 PyObject * obj3 = 0 ;
46484 PyObject * obj4 = 0 ;
46485 PyObject * obj5 = 0 ;
46486 char * kwnames[] = {
46487 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46488 };
46489
46490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46492 if (!SWIG_IsOK(res1)) {
46493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46494 }
46495 arg1 = reinterpret_cast< wxSizer * >(argp1);
46496 arg2 = obj1;
46497 if (obj2) {
46498 ecode3 = SWIG_AsVal_int(obj2, &val3);
46499 if (!SWIG_IsOK(ecode3)) {
46500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46501 }
46502 arg3 = static_cast< int >(val3);
46503 }
46504 if (obj3) {
46505 ecode4 = SWIG_AsVal_int(obj3, &val4);
46506 if (!SWIG_IsOK(ecode4)) {
46507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46508 }
46509 arg4 = static_cast< int >(val4);
46510 }
46511 if (obj4) {
46512 ecode5 = SWIG_AsVal_int(obj4, &val5);
46513 if (!SWIG_IsOK(ecode5)) {
46514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46515 }
46516 arg5 = static_cast< int >(val5);
46517 }
46518 if (obj5) {
46519 arg6 = obj5;
46520 }
46521 {
46522 PyThreadState* __tstate = wxPyBeginAllowThreads();
46523 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46524 wxPyEndAllowThreads(__tstate);
46525 if (PyErr_Occurred()) SWIG_fail;
46526 }
46527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46528 return resultobj;
46529 fail:
46530 return NULL;
46531 }
46532
46533
46534 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46535 PyObject *resultobj = 0;
46536 wxSizer *arg1 = (wxSizer *) 0 ;
46537 PyObject *arg2 = (PyObject *) 0 ;
46538 bool result;
46539 void *argp1 = 0 ;
46540 int res1 = 0 ;
46541 PyObject * obj0 = 0 ;
46542 PyObject * obj1 = 0 ;
46543 char * kwnames[] = {
46544 (char *) "self",(char *) "item", NULL
46545 };
46546
46547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46549 if (!SWIG_IsOK(res1)) {
46550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46551 }
46552 arg1 = reinterpret_cast< wxSizer * >(argp1);
46553 arg2 = obj1;
46554 {
46555 PyThreadState* __tstate = wxPyBeginAllowThreads();
46556 result = (bool)wxSizer_Remove(arg1,arg2);
46557 wxPyEndAllowThreads(__tstate);
46558 if (PyErr_Occurred()) SWIG_fail;
46559 }
46560 {
46561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46562 }
46563 return resultobj;
46564 fail:
46565 return NULL;
46566 }
46567
46568
46569 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46570 PyObject *resultobj = 0;
46571 wxSizer *arg1 = (wxSizer *) 0 ;
46572 PyObject *arg2 = (PyObject *) 0 ;
46573 bool result;
46574 void *argp1 = 0 ;
46575 int res1 = 0 ;
46576 PyObject * obj0 = 0 ;
46577 PyObject * obj1 = 0 ;
46578 char * kwnames[] = {
46579 (char *) "self",(char *) "item", NULL
46580 };
46581
46582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46584 if (!SWIG_IsOK(res1)) {
46585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46586 }
46587 arg1 = reinterpret_cast< wxSizer * >(argp1);
46588 arg2 = obj1;
46589 {
46590 PyThreadState* __tstate = wxPyBeginAllowThreads();
46591 result = (bool)wxSizer_Detach(arg1,arg2);
46592 wxPyEndAllowThreads(__tstate);
46593 if (PyErr_Occurred()) SWIG_fail;
46594 }
46595 {
46596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46597 }
46598 return resultobj;
46599 fail:
46600 return NULL;
46601 }
46602
46603
46604 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46605 PyObject *resultobj = 0;
46606 wxSizer *arg1 = (wxSizer *) 0 ;
46607 PyObject *arg2 = (PyObject *) 0 ;
46608 wxSizerItem *result = 0 ;
46609 void *argp1 = 0 ;
46610 int res1 = 0 ;
46611 PyObject * obj0 = 0 ;
46612 PyObject * obj1 = 0 ;
46613 char * kwnames[] = {
46614 (char *) "self",(char *) "item", NULL
46615 };
46616
46617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46621 }
46622 arg1 = reinterpret_cast< wxSizer * >(argp1);
46623 arg2 = obj1;
46624 {
46625 PyThreadState* __tstate = wxPyBeginAllowThreads();
46626 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46627 wxPyEndAllowThreads(__tstate);
46628 if (PyErr_Occurred()) SWIG_fail;
46629 }
46630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46631 return resultobj;
46632 fail:
46633 return NULL;
46634 }
46635
46636
46637 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46638 PyObject *resultobj = 0;
46639 wxSizer *arg1 = (wxSizer *) 0 ;
46640 PyObject *arg2 = (PyObject *) 0 ;
46641 wxSize *arg3 = 0 ;
46642 void *argp1 = 0 ;
46643 int res1 = 0 ;
46644 wxSize temp3 ;
46645 PyObject * obj0 = 0 ;
46646 PyObject * obj1 = 0 ;
46647 PyObject * obj2 = 0 ;
46648 char * kwnames[] = {
46649 (char *) "self",(char *) "item",(char *) "size", NULL
46650 };
46651
46652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46654 if (!SWIG_IsOK(res1)) {
46655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46656 }
46657 arg1 = reinterpret_cast< wxSizer * >(argp1);
46658 arg2 = obj1;
46659 {
46660 arg3 = &temp3;
46661 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46662 }
46663 {
46664 PyThreadState* __tstate = wxPyBeginAllowThreads();
46665 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46666 wxPyEndAllowThreads(__tstate);
46667 if (PyErr_Occurred()) SWIG_fail;
46668 }
46669 resultobj = SWIG_Py_Void();
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46677 PyObject *resultobj = 0;
46678 wxSizer *arg1 = (wxSizer *) 0 ;
46679 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46680 wxSizerItem *result = 0 ;
46681 void *argp1 = 0 ;
46682 int res1 = 0 ;
46683 int res2 = 0 ;
46684 PyObject * obj0 = 0 ;
46685 PyObject * obj1 = 0 ;
46686 char * kwnames[] = {
46687 (char *) "self",(char *) "item", NULL
46688 };
46689
46690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46692 if (!SWIG_IsOK(res1)) {
46693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46694 }
46695 arg1 = reinterpret_cast< wxSizer * >(argp1);
46696 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46697 if (!SWIG_IsOK(res2)) {
46698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46699 }
46700 {
46701 PyThreadState* __tstate = wxPyBeginAllowThreads();
46702 result = (wxSizerItem *)(arg1)->Add(arg2);
46703 wxPyEndAllowThreads(__tstate);
46704 if (PyErr_Occurred()) SWIG_fail;
46705 }
46706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46707 return resultobj;
46708 fail:
46709 return NULL;
46710 }
46711
46712
46713 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46714 PyObject *resultobj = 0;
46715 wxSizer *arg1 = (wxSizer *) 0 ;
46716 size_t arg2 ;
46717 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46718 wxSizerItem *result = 0 ;
46719 void *argp1 = 0 ;
46720 int res1 = 0 ;
46721 size_t val2 ;
46722 int ecode2 = 0 ;
46723 int res3 = 0 ;
46724 PyObject * obj0 = 0 ;
46725 PyObject * obj1 = 0 ;
46726 PyObject * obj2 = 0 ;
46727 char * kwnames[] = {
46728 (char *) "self",(char *) "index",(char *) "item", NULL
46729 };
46730
46731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46735 }
46736 arg1 = reinterpret_cast< wxSizer * >(argp1);
46737 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46738 if (!SWIG_IsOK(ecode2)) {
46739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46740 }
46741 arg2 = static_cast< size_t >(val2);
46742 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46743 if (!SWIG_IsOK(res3)) {
46744 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46745 }
46746 {
46747 PyThreadState* __tstate = wxPyBeginAllowThreads();
46748 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46749 wxPyEndAllowThreads(__tstate);
46750 if (PyErr_Occurred()) SWIG_fail;
46751 }
46752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46753 return resultobj;
46754 fail:
46755 return NULL;
46756 }
46757
46758
46759 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46760 PyObject *resultobj = 0;
46761 wxSizer *arg1 = (wxSizer *) 0 ;
46762 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46763 wxSizerItem *result = 0 ;
46764 void *argp1 = 0 ;
46765 int res1 = 0 ;
46766 int res2 = 0 ;
46767 PyObject * obj0 = 0 ;
46768 PyObject * obj1 = 0 ;
46769 char * kwnames[] = {
46770 (char *) "self",(char *) "item", NULL
46771 };
46772
46773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46775 if (!SWIG_IsOK(res1)) {
46776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46777 }
46778 arg1 = reinterpret_cast< wxSizer * >(argp1);
46779 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46780 if (!SWIG_IsOK(res2)) {
46781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46782 }
46783 {
46784 PyThreadState* __tstate = wxPyBeginAllowThreads();
46785 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46786 wxPyEndAllowThreads(__tstate);
46787 if (PyErr_Occurred()) SWIG_fail;
46788 }
46789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46790 return resultobj;
46791 fail:
46792 return NULL;
46793 }
46794
46795
46796 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46797 PyObject *resultobj = 0;
46798 wxSizer *arg1 = (wxSizer *) 0 ;
46799 int arg2 ;
46800 int arg3 ;
46801 int arg4 ;
46802 int arg5 ;
46803 void *argp1 = 0 ;
46804 int res1 = 0 ;
46805 int val2 ;
46806 int ecode2 = 0 ;
46807 int val3 ;
46808 int ecode3 = 0 ;
46809 int val4 ;
46810 int ecode4 = 0 ;
46811 int val5 ;
46812 int ecode5 = 0 ;
46813 PyObject * obj0 = 0 ;
46814 PyObject * obj1 = 0 ;
46815 PyObject * obj2 = 0 ;
46816 PyObject * obj3 = 0 ;
46817 PyObject * obj4 = 0 ;
46818 char * kwnames[] = {
46819 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46820 };
46821
46822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46824 if (!SWIG_IsOK(res1)) {
46825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46826 }
46827 arg1 = reinterpret_cast< wxSizer * >(argp1);
46828 ecode2 = SWIG_AsVal_int(obj1, &val2);
46829 if (!SWIG_IsOK(ecode2)) {
46830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46831 }
46832 arg2 = static_cast< int >(val2);
46833 ecode3 = SWIG_AsVal_int(obj2, &val3);
46834 if (!SWIG_IsOK(ecode3)) {
46835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46836 }
46837 arg3 = static_cast< int >(val3);
46838 ecode4 = SWIG_AsVal_int(obj3, &val4);
46839 if (!SWIG_IsOK(ecode4)) {
46840 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46841 }
46842 arg4 = static_cast< int >(val4);
46843 ecode5 = SWIG_AsVal_int(obj4, &val5);
46844 if (!SWIG_IsOK(ecode5)) {
46845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46846 }
46847 arg5 = static_cast< int >(val5);
46848 {
46849 PyThreadState* __tstate = wxPyBeginAllowThreads();
46850 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46851 wxPyEndAllowThreads(__tstate);
46852 if (PyErr_Occurred()) SWIG_fail;
46853 }
46854 resultobj = SWIG_Py_Void();
46855 return resultobj;
46856 fail:
46857 return NULL;
46858 }
46859
46860
46861 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46862 PyObject *resultobj = 0;
46863 wxSizer *arg1 = (wxSizer *) 0 ;
46864 wxSize *arg2 = 0 ;
46865 void *argp1 = 0 ;
46866 int res1 = 0 ;
46867 wxSize temp2 ;
46868 PyObject * obj0 = 0 ;
46869 PyObject * obj1 = 0 ;
46870 char * kwnames[] = {
46871 (char *) "self",(char *) "size", NULL
46872 };
46873
46874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46876 if (!SWIG_IsOK(res1)) {
46877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46878 }
46879 arg1 = reinterpret_cast< wxSizer * >(argp1);
46880 {
46881 arg2 = &temp2;
46882 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46883 }
46884 {
46885 PyThreadState* __tstate = wxPyBeginAllowThreads();
46886 (arg1)->SetMinSize((wxSize const &)*arg2);
46887 wxPyEndAllowThreads(__tstate);
46888 if (PyErr_Occurred()) SWIG_fail;
46889 }
46890 resultobj = SWIG_Py_Void();
46891 return resultobj;
46892 fail:
46893 return NULL;
46894 }
46895
46896
46897 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46898 PyObject *resultobj = 0;
46899 wxSizer *arg1 = (wxSizer *) 0 ;
46900 wxSize result;
46901 void *argp1 = 0 ;
46902 int res1 = 0 ;
46903 PyObject *swig_obj[1] ;
46904
46905 if (!args) SWIG_fail;
46906 swig_obj[0] = args;
46907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46908 if (!SWIG_IsOK(res1)) {
46909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46910 }
46911 arg1 = reinterpret_cast< wxSizer * >(argp1);
46912 {
46913 PyThreadState* __tstate = wxPyBeginAllowThreads();
46914 result = (arg1)->GetSize();
46915 wxPyEndAllowThreads(__tstate);
46916 if (PyErr_Occurred()) SWIG_fail;
46917 }
46918 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46919 return resultobj;
46920 fail:
46921 return NULL;
46922 }
46923
46924
46925 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46926 PyObject *resultobj = 0;
46927 wxSizer *arg1 = (wxSizer *) 0 ;
46928 wxPoint result;
46929 void *argp1 = 0 ;
46930 int res1 = 0 ;
46931 PyObject *swig_obj[1] ;
46932
46933 if (!args) SWIG_fail;
46934 swig_obj[0] = args;
46935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46936 if (!SWIG_IsOK(res1)) {
46937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46938 }
46939 arg1 = reinterpret_cast< wxSizer * >(argp1);
46940 {
46941 PyThreadState* __tstate = wxPyBeginAllowThreads();
46942 result = (arg1)->GetPosition();
46943 wxPyEndAllowThreads(__tstate);
46944 if (PyErr_Occurred()) SWIG_fail;
46945 }
46946 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46947 return resultobj;
46948 fail:
46949 return NULL;
46950 }
46951
46952
46953 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46954 PyObject *resultobj = 0;
46955 wxSizer *arg1 = (wxSizer *) 0 ;
46956 wxSize result;
46957 void *argp1 = 0 ;
46958 int res1 = 0 ;
46959 PyObject *swig_obj[1] ;
46960
46961 if (!args) SWIG_fail;
46962 swig_obj[0] = args;
46963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46964 if (!SWIG_IsOK(res1)) {
46965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46966 }
46967 arg1 = reinterpret_cast< wxSizer * >(argp1);
46968 {
46969 PyThreadState* __tstate = wxPyBeginAllowThreads();
46970 result = (arg1)->GetMinSize();
46971 wxPyEndAllowThreads(__tstate);
46972 if (PyErr_Occurred()) SWIG_fail;
46973 }
46974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46975 return resultobj;
46976 fail:
46977 return NULL;
46978 }
46979
46980
46981 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46982 PyObject *resultobj = 0;
46983 wxSizer *arg1 = (wxSizer *) 0 ;
46984 void *argp1 = 0 ;
46985 int res1 = 0 ;
46986 PyObject *swig_obj[1] ;
46987
46988 if (!args) SWIG_fail;
46989 swig_obj[0] = args;
46990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46991 if (!SWIG_IsOK(res1)) {
46992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46993 }
46994 arg1 = reinterpret_cast< wxSizer * >(argp1);
46995 {
46996 PyThreadState* __tstate = wxPyBeginAllowThreads();
46997 (arg1)->RecalcSizes();
46998 wxPyEndAllowThreads(__tstate);
46999 if (PyErr_Occurred()) SWIG_fail;
47000 }
47001 resultobj = SWIG_Py_Void();
47002 return resultobj;
47003 fail:
47004 return NULL;
47005 }
47006
47007
47008 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47009 PyObject *resultobj = 0;
47010 wxSizer *arg1 = (wxSizer *) 0 ;
47011 wxSize result;
47012 void *argp1 = 0 ;
47013 int res1 = 0 ;
47014 PyObject *swig_obj[1] ;
47015
47016 if (!args) SWIG_fail;
47017 swig_obj[0] = args;
47018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47019 if (!SWIG_IsOK(res1)) {
47020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47021 }
47022 arg1 = reinterpret_cast< wxSizer * >(argp1);
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 result = (arg1)->CalcMin();
47026 wxPyEndAllowThreads(__tstate);
47027 if (PyErr_Occurred()) SWIG_fail;
47028 }
47029 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47030 return resultobj;
47031 fail:
47032 return NULL;
47033 }
47034
47035
47036 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47037 PyObject *resultobj = 0;
47038 wxSizer *arg1 = (wxSizer *) 0 ;
47039 void *argp1 = 0 ;
47040 int res1 = 0 ;
47041 PyObject *swig_obj[1] ;
47042
47043 if (!args) SWIG_fail;
47044 swig_obj[0] = args;
47045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47046 if (!SWIG_IsOK(res1)) {
47047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47048 }
47049 arg1 = reinterpret_cast< wxSizer * >(argp1);
47050 {
47051 PyThreadState* __tstate = wxPyBeginAllowThreads();
47052 (arg1)->Layout();
47053 wxPyEndAllowThreads(__tstate);
47054 if (PyErr_Occurred()) SWIG_fail;
47055 }
47056 resultobj = SWIG_Py_Void();
47057 return resultobj;
47058 fail:
47059 return NULL;
47060 }
47061
47062
47063 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47064 PyObject *resultobj = 0;
47065 wxSizer *arg1 = (wxSizer *) 0 ;
47066 wxWindow *arg2 = (wxWindow *) 0 ;
47067 wxSize result;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 void *argp2 = 0 ;
47071 int res2 = 0 ;
47072 PyObject * obj0 = 0 ;
47073 PyObject * obj1 = 0 ;
47074 char * kwnames[] = {
47075 (char *) "self",(char *) "window", NULL
47076 };
47077
47078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47080 if (!SWIG_IsOK(res1)) {
47081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47082 }
47083 arg1 = reinterpret_cast< wxSizer * >(argp1);
47084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47085 if (!SWIG_IsOK(res2)) {
47086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47087 }
47088 arg2 = reinterpret_cast< wxWindow * >(argp2);
47089 {
47090 PyThreadState* __tstate = wxPyBeginAllowThreads();
47091 result = (arg1)->Fit(arg2);
47092 wxPyEndAllowThreads(__tstate);
47093 if (PyErr_Occurred()) SWIG_fail;
47094 }
47095 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47096 return resultobj;
47097 fail:
47098 return NULL;
47099 }
47100
47101
47102 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47103 PyObject *resultobj = 0;
47104 wxSizer *arg1 = (wxSizer *) 0 ;
47105 wxWindow *arg2 = (wxWindow *) 0 ;
47106 void *argp1 = 0 ;
47107 int res1 = 0 ;
47108 void *argp2 = 0 ;
47109 int res2 = 0 ;
47110 PyObject * obj0 = 0 ;
47111 PyObject * obj1 = 0 ;
47112 char * kwnames[] = {
47113 (char *) "self",(char *) "window", NULL
47114 };
47115
47116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47118 if (!SWIG_IsOK(res1)) {
47119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47120 }
47121 arg1 = reinterpret_cast< wxSizer * >(argp1);
47122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47123 if (!SWIG_IsOK(res2)) {
47124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47125 }
47126 arg2 = reinterpret_cast< wxWindow * >(argp2);
47127 {
47128 PyThreadState* __tstate = wxPyBeginAllowThreads();
47129 (arg1)->FitInside(arg2);
47130 wxPyEndAllowThreads(__tstate);
47131 if (PyErr_Occurred()) SWIG_fail;
47132 }
47133 resultobj = SWIG_Py_Void();
47134 return resultobj;
47135 fail:
47136 return NULL;
47137 }
47138
47139
47140 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47141 PyObject *resultobj = 0;
47142 wxSizer *arg1 = (wxSizer *) 0 ;
47143 wxWindow *arg2 = (wxWindow *) 0 ;
47144 void *argp1 = 0 ;
47145 int res1 = 0 ;
47146 void *argp2 = 0 ;
47147 int res2 = 0 ;
47148 PyObject * obj0 = 0 ;
47149 PyObject * obj1 = 0 ;
47150 char * kwnames[] = {
47151 (char *) "self",(char *) "window", NULL
47152 };
47153
47154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47156 if (!SWIG_IsOK(res1)) {
47157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47158 }
47159 arg1 = reinterpret_cast< wxSizer * >(argp1);
47160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47161 if (!SWIG_IsOK(res2)) {
47162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47163 }
47164 arg2 = reinterpret_cast< wxWindow * >(argp2);
47165 {
47166 PyThreadState* __tstate = wxPyBeginAllowThreads();
47167 (arg1)->SetSizeHints(arg2);
47168 wxPyEndAllowThreads(__tstate);
47169 if (PyErr_Occurred()) SWIG_fail;
47170 }
47171 resultobj = SWIG_Py_Void();
47172 return resultobj;
47173 fail:
47174 return NULL;
47175 }
47176
47177
47178 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47179 PyObject *resultobj = 0;
47180 wxSizer *arg1 = (wxSizer *) 0 ;
47181 wxWindow *arg2 = (wxWindow *) 0 ;
47182 void *argp1 = 0 ;
47183 int res1 = 0 ;
47184 void *argp2 = 0 ;
47185 int res2 = 0 ;
47186 PyObject * obj0 = 0 ;
47187 PyObject * obj1 = 0 ;
47188 char * kwnames[] = {
47189 (char *) "self",(char *) "window", NULL
47190 };
47191
47192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47194 if (!SWIG_IsOK(res1)) {
47195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47196 }
47197 arg1 = reinterpret_cast< wxSizer * >(argp1);
47198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47199 if (!SWIG_IsOK(res2)) {
47200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47201 }
47202 arg2 = reinterpret_cast< wxWindow * >(argp2);
47203 {
47204 PyThreadState* __tstate = wxPyBeginAllowThreads();
47205 (arg1)->SetVirtualSizeHints(arg2);
47206 wxPyEndAllowThreads(__tstate);
47207 if (PyErr_Occurred()) SWIG_fail;
47208 }
47209 resultobj = SWIG_Py_Void();
47210 return resultobj;
47211 fail:
47212 return NULL;
47213 }
47214
47215
47216 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47217 PyObject *resultobj = 0;
47218 wxSizer *arg1 = (wxSizer *) 0 ;
47219 bool arg2 = (bool) false ;
47220 void *argp1 = 0 ;
47221 int res1 = 0 ;
47222 bool val2 ;
47223 int ecode2 = 0 ;
47224 PyObject * obj0 = 0 ;
47225 PyObject * obj1 = 0 ;
47226 char * kwnames[] = {
47227 (char *) "self",(char *) "deleteWindows", NULL
47228 };
47229
47230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47232 if (!SWIG_IsOK(res1)) {
47233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47234 }
47235 arg1 = reinterpret_cast< wxSizer * >(argp1);
47236 if (obj1) {
47237 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47238 if (!SWIG_IsOK(ecode2)) {
47239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47240 }
47241 arg2 = static_cast< bool >(val2);
47242 }
47243 {
47244 PyThreadState* __tstate = wxPyBeginAllowThreads();
47245 (arg1)->Clear(arg2);
47246 wxPyEndAllowThreads(__tstate);
47247 if (PyErr_Occurred()) SWIG_fail;
47248 }
47249 resultobj = SWIG_Py_Void();
47250 return resultobj;
47251 fail:
47252 return NULL;
47253 }
47254
47255
47256 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47257 PyObject *resultobj = 0;
47258 wxSizer *arg1 = (wxSizer *) 0 ;
47259 void *argp1 = 0 ;
47260 int res1 = 0 ;
47261 PyObject *swig_obj[1] ;
47262
47263 if (!args) SWIG_fail;
47264 swig_obj[0] = args;
47265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47266 if (!SWIG_IsOK(res1)) {
47267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47268 }
47269 arg1 = reinterpret_cast< wxSizer * >(argp1);
47270 {
47271 PyThreadState* __tstate = wxPyBeginAllowThreads();
47272 (arg1)->DeleteWindows();
47273 wxPyEndAllowThreads(__tstate);
47274 if (PyErr_Occurred()) SWIG_fail;
47275 }
47276 resultobj = SWIG_Py_Void();
47277 return resultobj;
47278 fail:
47279 return NULL;
47280 }
47281
47282
47283 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47284 PyObject *resultobj = 0;
47285 wxSizer *arg1 = (wxSizer *) 0 ;
47286 PyObject *result = 0 ;
47287 void *argp1 = 0 ;
47288 int res1 = 0 ;
47289 PyObject *swig_obj[1] ;
47290
47291 if (!args) SWIG_fail;
47292 swig_obj[0] = args;
47293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47294 if (!SWIG_IsOK(res1)) {
47295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47296 }
47297 arg1 = reinterpret_cast< wxSizer * >(argp1);
47298 {
47299 PyThreadState* __tstate = wxPyBeginAllowThreads();
47300 result = (PyObject *)wxSizer_GetChildren(arg1);
47301 wxPyEndAllowThreads(__tstate);
47302 if (PyErr_Occurred()) SWIG_fail;
47303 }
47304 resultobj = result;
47305 return resultobj;
47306 fail:
47307 return NULL;
47308 }
47309
47310
47311 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47312 PyObject *resultobj = 0;
47313 wxSizer *arg1 = (wxSizer *) 0 ;
47314 PyObject *arg2 = (PyObject *) 0 ;
47315 bool arg3 = (bool) true ;
47316 bool arg4 = (bool) false ;
47317 bool result;
47318 void *argp1 = 0 ;
47319 int res1 = 0 ;
47320 bool val3 ;
47321 int ecode3 = 0 ;
47322 bool val4 ;
47323 int ecode4 = 0 ;
47324 PyObject * obj0 = 0 ;
47325 PyObject * obj1 = 0 ;
47326 PyObject * obj2 = 0 ;
47327 PyObject * obj3 = 0 ;
47328 char * kwnames[] = {
47329 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47330 };
47331
47332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47334 if (!SWIG_IsOK(res1)) {
47335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47336 }
47337 arg1 = reinterpret_cast< wxSizer * >(argp1);
47338 arg2 = obj1;
47339 if (obj2) {
47340 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47341 if (!SWIG_IsOK(ecode3)) {
47342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47343 }
47344 arg3 = static_cast< bool >(val3);
47345 }
47346 if (obj3) {
47347 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47348 if (!SWIG_IsOK(ecode4)) {
47349 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47350 }
47351 arg4 = static_cast< bool >(val4);
47352 }
47353 {
47354 PyThreadState* __tstate = wxPyBeginAllowThreads();
47355 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47356 wxPyEndAllowThreads(__tstate);
47357 if (PyErr_Occurred()) SWIG_fail;
47358 }
47359 {
47360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47361 }
47362 return resultobj;
47363 fail:
47364 return NULL;
47365 }
47366
47367
47368 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47369 PyObject *resultobj = 0;
47370 wxSizer *arg1 = (wxSizer *) 0 ;
47371 PyObject *arg2 = (PyObject *) 0 ;
47372 bool result;
47373 void *argp1 = 0 ;
47374 int res1 = 0 ;
47375 PyObject * obj0 = 0 ;
47376 PyObject * obj1 = 0 ;
47377 char * kwnames[] = {
47378 (char *) "self",(char *) "item", NULL
47379 };
47380
47381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47383 if (!SWIG_IsOK(res1)) {
47384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47385 }
47386 arg1 = reinterpret_cast< wxSizer * >(argp1);
47387 arg2 = obj1;
47388 {
47389 PyThreadState* __tstate = wxPyBeginAllowThreads();
47390 result = (bool)wxSizer_IsShown(arg1,arg2);
47391 wxPyEndAllowThreads(__tstate);
47392 if (PyErr_Occurred()) SWIG_fail;
47393 }
47394 {
47395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47396 }
47397 return resultobj;
47398 fail:
47399 return NULL;
47400 }
47401
47402
47403 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47404 PyObject *resultobj = 0;
47405 wxSizer *arg1 = (wxSizer *) 0 ;
47406 bool arg2 ;
47407 void *argp1 = 0 ;
47408 int res1 = 0 ;
47409 bool val2 ;
47410 int ecode2 = 0 ;
47411 PyObject * obj0 = 0 ;
47412 PyObject * obj1 = 0 ;
47413 char * kwnames[] = {
47414 (char *) "self",(char *) "show", NULL
47415 };
47416
47417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47419 if (!SWIG_IsOK(res1)) {
47420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47421 }
47422 arg1 = reinterpret_cast< wxSizer * >(argp1);
47423 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47424 if (!SWIG_IsOK(ecode2)) {
47425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47426 }
47427 arg2 = static_cast< bool >(val2);
47428 {
47429 PyThreadState* __tstate = wxPyBeginAllowThreads();
47430 (arg1)->ShowItems(arg2);
47431 wxPyEndAllowThreads(__tstate);
47432 if (PyErr_Occurred()) SWIG_fail;
47433 }
47434 resultobj = SWIG_Py_Void();
47435 return resultobj;
47436 fail:
47437 return NULL;
47438 }
47439
47440
47441 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47442 PyObject *obj;
47443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47444 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47445 return SWIG_Py_Void();
47446 }
47447
47448 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47449 PyObject *resultobj = 0;
47450 wxPySizer *result = 0 ;
47451
47452 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47453 {
47454 PyThreadState* __tstate = wxPyBeginAllowThreads();
47455 result = (wxPySizer *)new wxPySizer();
47456 wxPyEndAllowThreads(__tstate);
47457 if (PyErr_Occurred()) SWIG_fail;
47458 }
47459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47460 return resultobj;
47461 fail:
47462 return NULL;
47463 }
47464
47465
47466 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47467 PyObject *resultobj = 0;
47468 wxPySizer *arg1 = (wxPySizer *) 0 ;
47469 PyObject *arg2 = (PyObject *) 0 ;
47470 PyObject *arg3 = (PyObject *) 0 ;
47471 void *argp1 = 0 ;
47472 int res1 = 0 ;
47473 PyObject * obj0 = 0 ;
47474 PyObject * obj1 = 0 ;
47475 PyObject * obj2 = 0 ;
47476 char * kwnames[] = {
47477 (char *) "self",(char *) "self",(char *) "_class", NULL
47478 };
47479
47480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47482 if (!SWIG_IsOK(res1)) {
47483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47484 }
47485 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47486 arg2 = obj1;
47487 arg3 = obj2;
47488 {
47489 PyThreadState* __tstate = wxPyBeginAllowThreads();
47490 (arg1)->_setCallbackInfo(arg2,arg3);
47491 wxPyEndAllowThreads(__tstate);
47492 if (PyErr_Occurred()) SWIG_fail;
47493 }
47494 resultobj = SWIG_Py_Void();
47495 return resultobj;
47496 fail:
47497 return NULL;
47498 }
47499
47500
47501 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47502 PyObject *obj;
47503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47504 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47505 return SWIG_Py_Void();
47506 }
47507
47508 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47509 return SWIG_Python_InitShadowInstance(args);
47510 }
47511
47512 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47513 PyObject *resultobj = 0;
47514 int arg1 = (int) wxHORIZONTAL ;
47515 wxBoxSizer *result = 0 ;
47516 int val1 ;
47517 int ecode1 = 0 ;
47518 PyObject * obj0 = 0 ;
47519 char * kwnames[] = {
47520 (char *) "orient", NULL
47521 };
47522
47523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47524 if (obj0) {
47525 ecode1 = SWIG_AsVal_int(obj0, &val1);
47526 if (!SWIG_IsOK(ecode1)) {
47527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47528 }
47529 arg1 = static_cast< int >(val1);
47530 }
47531 {
47532 PyThreadState* __tstate = wxPyBeginAllowThreads();
47533 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47534 wxPyEndAllowThreads(__tstate);
47535 if (PyErr_Occurred()) SWIG_fail;
47536 }
47537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47538 return resultobj;
47539 fail:
47540 return NULL;
47541 }
47542
47543
47544 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47545 PyObject *resultobj = 0;
47546 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47547 int result;
47548 void *argp1 = 0 ;
47549 int res1 = 0 ;
47550 PyObject *swig_obj[1] ;
47551
47552 if (!args) SWIG_fail;
47553 swig_obj[0] = args;
47554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47555 if (!SWIG_IsOK(res1)) {
47556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47557 }
47558 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47559 {
47560 PyThreadState* __tstate = wxPyBeginAllowThreads();
47561 result = (int)(arg1)->GetOrientation();
47562 wxPyEndAllowThreads(__tstate);
47563 if (PyErr_Occurred()) SWIG_fail;
47564 }
47565 resultobj = SWIG_From_int(static_cast< int >(result));
47566 return resultobj;
47567 fail:
47568 return NULL;
47569 }
47570
47571
47572 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47573 PyObject *resultobj = 0;
47574 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47575 int arg2 ;
47576 void *argp1 = 0 ;
47577 int res1 = 0 ;
47578 int val2 ;
47579 int ecode2 = 0 ;
47580 PyObject * obj0 = 0 ;
47581 PyObject * obj1 = 0 ;
47582 char * kwnames[] = {
47583 (char *) "self",(char *) "orient", NULL
47584 };
47585
47586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47588 if (!SWIG_IsOK(res1)) {
47589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47590 }
47591 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47592 ecode2 = SWIG_AsVal_int(obj1, &val2);
47593 if (!SWIG_IsOK(ecode2)) {
47594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47595 }
47596 arg2 = static_cast< int >(val2);
47597 {
47598 PyThreadState* __tstate = wxPyBeginAllowThreads();
47599 (arg1)->SetOrientation(arg2);
47600 wxPyEndAllowThreads(__tstate);
47601 if (PyErr_Occurred()) SWIG_fail;
47602 }
47603 resultobj = SWIG_Py_Void();
47604 return resultobj;
47605 fail:
47606 return NULL;
47607 }
47608
47609
47610 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47611 PyObject *obj;
47612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47613 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47614 return SWIG_Py_Void();
47615 }
47616
47617 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47618 return SWIG_Python_InitShadowInstance(args);
47619 }
47620
47621 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47622 PyObject *resultobj = 0;
47623 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47624 int arg2 = (int) wxHORIZONTAL ;
47625 wxStaticBoxSizer *result = 0 ;
47626 void *argp1 = 0 ;
47627 int res1 = 0 ;
47628 int val2 ;
47629 int ecode2 = 0 ;
47630 PyObject * obj0 = 0 ;
47631 PyObject * obj1 = 0 ;
47632 char * kwnames[] = {
47633 (char *) "box",(char *) "orient", NULL
47634 };
47635
47636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47638 if (!SWIG_IsOK(res1)) {
47639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47640 }
47641 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47642 if (obj1) {
47643 ecode2 = SWIG_AsVal_int(obj1, &val2);
47644 if (!SWIG_IsOK(ecode2)) {
47645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47646 }
47647 arg2 = static_cast< int >(val2);
47648 }
47649 {
47650 PyThreadState* __tstate = wxPyBeginAllowThreads();
47651 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47652 wxPyEndAllowThreads(__tstate);
47653 if (PyErr_Occurred()) SWIG_fail;
47654 }
47655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47656 return resultobj;
47657 fail:
47658 return NULL;
47659 }
47660
47661
47662 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47663 PyObject *resultobj = 0;
47664 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47665 wxStaticBox *result = 0 ;
47666 void *argp1 = 0 ;
47667 int res1 = 0 ;
47668 PyObject *swig_obj[1] ;
47669
47670 if (!args) SWIG_fail;
47671 swig_obj[0] = args;
47672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47673 if (!SWIG_IsOK(res1)) {
47674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47675 }
47676 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47677 {
47678 PyThreadState* __tstate = wxPyBeginAllowThreads();
47679 result = (wxStaticBox *)(arg1)->GetStaticBox();
47680 wxPyEndAllowThreads(__tstate);
47681 if (PyErr_Occurred()) SWIG_fail;
47682 }
47683 {
47684 resultobj = wxPyMake_wxObject(result, (bool)0);
47685 }
47686 return resultobj;
47687 fail:
47688 return NULL;
47689 }
47690
47691
47692 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47693 PyObject *obj;
47694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47695 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47696 return SWIG_Py_Void();
47697 }
47698
47699 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47700 return SWIG_Python_InitShadowInstance(args);
47701 }
47702
47703 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47704 PyObject *resultobj = 0;
47705 int arg1 = (int) 1 ;
47706 int arg2 = (int) 0 ;
47707 int arg3 = (int) 0 ;
47708 int arg4 = (int) 0 ;
47709 wxGridSizer *result = 0 ;
47710 int val1 ;
47711 int ecode1 = 0 ;
47712 int val2 ;
47713 int ecode2 = 0 ;
47714 int val3 ;
47715 int ecode3 = 0 ;
47716 int val4 ;
47717 int ecode4 = 0 ;
47718 PyObject * obj0 = 0 ;
47719 PyObject * obj1 = 0 ;
47720 PyObject * obj2 = 0 ;
47721 PyObject * obj3 = 0 ;
47722 char * kwnames[] = {
47723 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47724 };
47725
47726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47727 if (obj0) {
47728 ecode1 = SWIG_AsVal_int(obj0, &val1);
47729 if (!SWIG_IsOK(ecode1)) {
47730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47731 }
47732 arg1 = static_cast< int >(val1);
47733 }
47734 if (obj1) {
47735 ecode2 = SWIG_AsVal_int(obj1, &val2);
47736 if (!SWIG_IsOK(ecode2)) {
47737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47738 }
47739 arg2 = static_cast< int >(val2);
47740 }
47741 if (obj2) {
47742 ecode3 = SWIG_AsVal_int(obj2, &val3);
47743 if (!SWIG_IsOK(ecode3)) {
47744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47745 }
47746 arg3 = static_cast< int >(val3);
47747 }
47748 if (obj3) {
47749 ecode4 = SWIG_AsVal_int(obj3, &val4);
47750 if (!SWIG_IsOK(ecode4)) {
47751 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47752 }
47753 arg4 = static_cast< int >(val4);
47754 }
47755 {
47756 PyThreadState* __tstate = wxPyBeginAllowThreads();
47757 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47758 wxPyEndAllowThreads(__tstate);
47759 if (PyErr_Occurred()) SWIG_fail;
47760 }
47761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47762 return resultobj;
47763 fail:
47764 return NULL;
47765 }
47766
47767
47768 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47769 PyObject *resultobj = 0;
47770 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47771 int arg2 ;
47772 void *argp1 = 0 ;
47773 int res1 = 0 ;
47774 int val2 ;
47775 int ecode2 = 0 ;
47776 PyObject * obj0 = 0 ;
47777 PyObject * obj1 = 0 ;
47778 char * kwnames[] = {
47779 (char *) "self",(char *) "cols", NULL
47780 };
47781
47782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47784 if (!SWIG_IsOK(res1)) {
47785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47786 }
47787 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47788 ecode2 = SWIG_AsVal_int(obj1, &val2);
47789 if (!SWIG_IsOK(ecode2)) {
47790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47791 }
47792 arg2 = static_cast< int >(val2);
47793 {
47794 PyThreadState* __tstate = wxPyBeginAllowThreads();
47795 (arg1)->SetCols(arg2);
47796 wxPyEndAllowThreads(__tstate);
47797 if (PyErr_Occurred()) SWIG_fail;
47798 }
47799 resultobj = SWIG_Py_Void();
47800 return resultobj;
47801 fail:
47802 return NULL;
47803 }
47804
47805
47806 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47807 PyObject *resultobj = 0;
47808 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47809 int arg2 ;
47810 void *argp1 = 0 ;
47811 int res1 = 0 ;
47812 int val2 ;
47813 int ecode2 = 0 ;
47814 PyObject * obj0 = 0 ;
47815 PyObject * obj1 = 0 ;
47816 char * kwnames[] = {
47817 (char *) "self",(char *) "rows", NULL
47818 };
47819
47820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47822 if (!SWIG_IsOK(res1)) {
47823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47824 }
47825 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47826 ecode2 = SWIG_AsVal_int(obj1, &val2);
47827 if (!SWIG_IsOK(ecode2)) {
47828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47829 }
47830 arg2 = static_cast< int >(val2);
47831 {
47832 PyThreadState* __tstate = wxPyBeginAllowThreads();
47833 (arg1)->SetRows(arg2);
47834 wxPyEndAllowThreads(__tstate);
47835 if (PyErr_Occurred()) SWIG_fail;
47836 }
47837 resultobj = SWIG_Py_Void();
47838 return resultobj;
47839 fail:
47840 return NULL;
47841 }
47842
47843
47844 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47845 PyObject *resultobj = 0;
47846 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47847 int arg2 ;
47848 void *argp1 = 0 ;
47849 int res1 = 0 ;
47850 int val2 ;
47851 int ecode2 = 0 ;
47852 PyObject * obj0 = 0 ;
47853 PyObject * obj1 = 0 ;
47854 char * kwnames[] = {
47855 (char *) "self",(char *) "gap", NULL
47856 };
47857
47858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47860 if (!SWIG_IsOK(res1)) {
47861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47862 }
47863 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47864 ecode2 = SWIG_AsVal_int(obj1, &val2);
47865 if (!SWIG_IsOK(ecode2)) {
47866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47867 }
47868 arg2 = static_cast< int >(val2);
47869 {
47870 PyThreadState* __tstate = wxPyBeginAllowThreads();
47871 (arg1)->SetVGap(arg2);
47872 wxPyEndAllowThreads(__tstate);
47873 if (PyErr_Occurred()) SWIG_fail;
47874 }
47875 resultobj = SWIG_Py_Void();
47876 return resultobj;
47877 fail:
47878 return NULL;
47879 }
47880
47881
47882 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47883 PyObject *resultobj = 0;
47884 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47885 int arg2 ;
47886 void *argp1 = 0 ;
47887 int res1 = 0 ;
47888 int val2 ;
47889 int ecode2 = 0 ;
47890 PyObject * obj0 = 0 ;
47891 PyObject * obj1 = 0 ;
47892 char * kwnames[] = {
47893 (char *) "self",(char *) "gap", NULL
47894 };
47895
47896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47898 if (!SWIG_IsOK(res1)) {
47899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47900 }
47901 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47902 ecode2 = SWIG_AsVal_int(obj1, &val2);
47903 if (!SWIG_IsOK(ecode2)) {
47904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47905 }
47906 arg2 = static_cast< int >(val2);
47907 {
47908 PyThreadState* __tstate = wxPyBeginAllowThreads();
47909 (arg1)->SetHGap(arg2);
47910 wxPyEndAllowThreads(__tstate);
47911 if (PyErr_Occurred()) SWIG_fail;
47912 }
47913 resultobj = SWIG_Py_Void();
47914 return resultobj;
47915 fail:
47916 return NULL;
47917 }
47918
47919
47920 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47921 PyObject *resultobj = 0;
47922 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47923 int result;
47924 void *argp1 = 0 ;
47925 int res1 = 0 ;
47926 PyObject *swig_obj[1] ;
47927
47928 if (!args) SWIG_fail;
47929 swig_obj[0] = args;
47930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47931 if (!SWIG_IsOK(res1)) {
47932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47933 }
47934 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47935 {
47936 PyThreadState* __tstate = wxPyBeginAllowThreads();
47937 result = (int)(arg1)->GetCols();
47938 wxPyEndAllowThreads(__tstate);
47939 if (PyErr_Occurred()) SWIG_fail;
47940 }
47941 resultobj = SWIG_From_int(static_cast< int >(result));
47942 return resultobj;
47943 fail:
47944 return NULL;
47945 }
47946
47947
47948 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47949 PyObject *resultobj = 0;
47950 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47951 int result;
47952 void *argp1 = 0 ;
47953 int res1 = 0 ;
47954 PyObject *swig_obj[1] ;
47955
47956 if (!args) SWIG_fail;
47957 swig_obj[0] = args;
47958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47959 if (!SWIG_IsOK(res1)) {
47960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47961 }
47962 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47963 {
47964 PyThreadState* __tstate = wxPyBeginAllowThreads();
47965 result = (int)(arg1)->GetRows();
47966 wxPyEndAllowThreads(__tstate);
47967 if (PyErr_Occurred()) SWIG_fail;
47968 }
47969 resultobj = SWIG_From_int(static_cast< int >(result));
47970 return resultobj;
47971 fail:
47972 return NULL;
47973 }
47974
47975
47976 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47977 PyObject *resultobj = 0;
47978 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47979 int result;
47980 void *argp1 = 0 ;
47981 int res1 = 0 ;
47982 PyObject *swig_obj[1] ;
47983
47984 if (!args) SWIG_fail;
47985 swig_obj[0] = args;
47986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47989 }
47990 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47991 {
47992 PyThreadState* __tstate = wxPyBeginAllowThreads();
47993 result = (int)(arg1)->GetVGap();
47994 wxPyEndAllowThreads(__tstate);
47995 if (PyErr_Occurred()) SWIG_fail;
47996 }
47997 resultobj = SWIG_From_int(static_cast< int >(result));
47998 return resultobj;
47999 fail:
48000 return NULL;
48001 }
48002
48003
48004 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48005 PyObject *resultobj = 0;
48006 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48007 int result;
48008 void *argp1 = 0 ;
48009 int res1 = 0 ;
48010 PyObject *swig_obj[1] ;
48011
48012 if (!args) SWIG_fail;
48013 swig_obj[0] = args;
48014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48015 if (!SWIG_IsOK(res1)) {
48016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48017 }
48018 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48019 {
48020 PyThreadState* __tstate = wxPyBeginAllowThreads();
48021 result = (int)(arg1)->GetHGap();
48022 wxPyEndAllowThreads(__tstate);
48023 if (PyErr_Occurred()) SWIG_fail;
48024 }
48025 resultobj = SWIG_From_int(static_cast< int >(result));
48026 return resultobj;
48027 fail:
48028 return NULL;
48029 }
48030
48031
48032 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48033 PyObject *obj;
48034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48035 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48036 return SWIG_Py_Void();
48037 }
48038
48039 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48040 return SWIG_Python_InitShadowInstance(args);
48041 }
48042
48043 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48044 PyObject *resultobj = 0;
48045 int arg1 = (int) 1 ;
48046 int arg2 = (int) 0 ;
48047 int arg3 = (int) 0 ;
48048 int arg4 = (int) 0 ;
48049 wxFlexGridSizer *result = 0 ;
48050 int val1 ;
48051 int ecode1 = 0 ;
48052 int val2 ;
48053 int ecode2 = 0 ;
48054 int val3 ;
48055 int ecode3 = 0 ;
48056 int val4 ;
48057 int ecode4 = 0 ;
48058 PyObject * obj0 = 0 ;
48059 PyObject * obj1 = 0 ;
48060 PyObject * obj2 = 0 ;
48061 PyObject * obj3 = 0 ;
48062 char * kwnames[] = {
48063 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48064 };
48065
48066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48067 if (obj0) {
48068 ecode1 = SWIG_AsVal_int(obj0, &val1);
48069 if (!SWIG_IsOK(ecode1)) {
48070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48071 }
48072 arg1 = static_cast< int >(val1);
48073 }
48074 if (obj1) {
48075 ecode2 = SWIG_AsVal_int(obj1, &val2);
48076 if (!SWIG_IsOK(ecode2)) {
48077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48078 }
48079 arg2 = static_cast< int >(val2);
48080 }
48081 if (obj2) {
48082 ecode3 = SWIG_AsVal_int(obj2, &val3);
48083 if (!SWIG_IsOK(ecode3)) {
48084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48085 }
48086 arg3 = static_cast< int >(val3);
48087 }
48088 if (obj3) {
48089 ecode4 = SWIG_AsVal_int(obj3, &val4);
48090 if (!SWIG_IsOK(ecode4)) {
48091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48092 }
48093 arg4 = static_cast< int >(val4);
48094 }
48095 {
48096 PyThreadState* __tstate = wxPyBeginAllowThreads();
48097 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48098 wxPyEndAllowThreads(__tstate);
48099 if (PyErr_Occurred()) SWIG_fail;
48100 }
48101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48102 return resultobj;
48103 fail:
48104 return NULL;
48105 }
48106
48107
48108 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48109 PyObject *resultobj = 0;
48110 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48111 size_t arg2 ;
48112 int arg3 = (int) 0 ;
48113 void *argp1 = 0 ;
48114 int res1 = 0 ;
48115 size_t val2 ;
48116 int ecode2 = 0 ;
48117 int val3 ;
48118 int ecode3 = 0 ;
48119 PyObject * obj0 = 0 ;
48120 PyObject * obj1 = 0 ;
48121 PyObject * obj2 = 0 ;
48122 char * kwnames[] = {
48123 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48124 };
48125
48126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48128 if (!SWIG_IsOK(res1)) {
48129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48130 }
48131 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48132 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48133 if (!SWIG_IsOK(ecode2)) {
48134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48135 }
48136 arg2 = static_cast< size_t >(val2);
48137 if (obj2) {
48138 ecode3 = SWIG_AsVal_int(obj2, &val3);
48139 if (!SWIG_IsOK(ecode3)) {
48140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48141 }
48142 arg3 = static_cast< int >(val3);
48143 }
48144 {
48145 PyThreadState* __tstate = wxPyBeginAllowThreads();
48146 (arg1)->AddGrowableRow(arg2,arg3);
48147 wxPyEndAllowThreads(__tstate);
48148 if (PyErr_Occurred()) SWIG_fail;
48149 }
48150 resultobj = SWIG_Py_Void();
48151 return resultobj;
48152 fail:
48153 return NULL;
48154 }
48155
48156
48157 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48158 PyObject *resultobj = 0;
48159 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48160 size_t arg2 ;
48161 void *argp1 = 0 ;
48162 int res1 = 0 ;
48163 size_t val2 ;
48164 int ecode2 = 0 ;
48165 PyObject * obj0 = 0 ;
48166 PyObject * obj1 = 0 ;
48167 char * kwnames[] = {
48168 (char *) "self",(char *) "idx", NULL
48169 };
48170
48171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48173 if (!SWIG_IsOK(res1)) {
48174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48175 }
48176 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48177 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48178 if (!SWIG_IsOK(ecode2)) {
48179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48180 }
48181 arg2 = static_cast< size_t >(val2);
48182 {
48183 PyThreadState* __tstate = wxPyBeginAllowThreads();
48184 (arg1)->RemoveGrowableRow(arg2);
48185 wxPyEndAllowThreads(__tstate);
48186 if (PyErr_Occurred()) SWIG_fail;
48187 }
48188 resultobj = SWIG_Py_Void();
48189 return resultobj;
48190 fail:
48191 return NULL;
48192 }
48193
48194
48195 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48196 PyObject *resultobj = 0;
48197 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48198 size_t arg2 ;
48199 int arg3 = (int) 0 ;
48200 void *argp1 = 0 ;
48201 int res1 = 0 ;
48202 size_t val2 ;
48203 int ecode2 = 0 ;
48204 int val3 ;
48205 int ecode3 = 0 ;
48206 PyObject * obj0 = 0 ;
48207 PyObject * obj1 = 0 ;
48208 PyObject * obj2 = 0 ;
48209 char * kwnames[] = {
48210 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48211 };
48212
48213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48215 if (!SWIG_IsOK(res1)) {
48216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48217 }
48218 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48219 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48220 if (!SWIG_IsOK(ecode2)) {
48221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48222 }
48223 arg2 = static_cast< size_t >(val2);
48224 if (obj2) {
48225 ecode3 = SWIG_AsVal_int(obj2, &val3);
48226 if (!SWIG_IsOK(ecode3)) {
48227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48228 }
48229 arg3 = static_cast< int >(val3);
48230 }
48231 {
48232 PyThreadState* __tstate = wxPyBeginAllowThreads();
48233 (arg1)->AddGrowableCol(arg2,arg3);
48234 wxPyEndAllowThreads(__tstate);
48235 if (PyErr_Occurred()) SWIG_fail;
48236 }
48237 resultobj = SWIG_Py_Void();
48238 return resultobj;
48239 fail:
48240 return NULL;
48241 }
48242
48243
48244 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48245 PyObject *resultobj = 0;
48246 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48247 size_t arg2 ;
48248 void *argp1 = 0 ;
48249 int res1 = 0 ;
48250 size_t val2 ;
48251 int ecode2 = 0 ;
48252 PyObject * obj0 = 0 ;
48253 PyObject * obj1 = 0 ;
48254 char * kwnames[] = {
48255 (char *) "self",(char *) "idx", NULL
48256 };
48257
48258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48260 if (!SWIG_IsOK(res1)) {
48261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48262 }
48263 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48264 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48265 if (!SWIG_IsOK(ecode2)) {
48266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48267 }
48268 arg2 = static_cast< size_t >(val2);
48269 {
48270 PyThreadState* __tstate = wxPyBeginAllowThreads();
48271 (arg1)->RemoveGrowableCol(arg2);
48272 wxPyEndAllowThreads(__tstate);
48273 if (PyErr_Occurred()) SWIG_fail;
48274 }
48275 resultobj = SWIG_Py_Void();
48276 return resultobj;
48277 fail:
48278 return NULL;
48279 }
48280
48281
48282 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48283 PyObject *resultobj = 0;
48284 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48285 int arg2 ;
48286 void *argp1 = 0 ;
48287 int res1 = 0 ;
48288 int val2 ;
48289 int ecode2 = 0 ;
48290 PyObject * obj0 = 0 ;
48291 PyObject * obj1 = 0 ;
48292 char * kwnames[] = {
48293 (char *) "self",(char *) "direction", NULL
48294 };
48295
48296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48298 if (!SWIG_IsOK(res1)) {
48299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48300 }
48301 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48302 ecode2 = SWIG_AsVal_int(obj1, &val2);
48303 if (!SWIG_IsOK(ecode2)) {
48304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48305 }
48306 arg2 = static_cast< int >(val2);
48307 {
48308 PyThreadState* __tstate = wxPyBeginAllowThreads();
48309 (arg1)->SetFlexibleDirection(arg2);
48310 wxPyEndAllowThreads(__tstate);
48311 if (PyErr_Occurred()) SWIG_fail;
48312 }
48313 resultobj = SWIG_Py_Void();
48314 return resultobj;
48315 fail:
48316 return NULL;
48317 }
48318
48319
48320 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48321 PyObject *resultobj = 0;
48322 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48323 int result;
48324 void *argp1 = 0 ;
48325 int res1 = 0 ;
48326 PyObject *swig_obj[1] ;
48327
48328 if (!args) SWIG_fail;
48329 swig_obj[0] = args;
48330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48331 if (!SWIG_IsOK(res1)) {
48332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48333 }
48334 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48335 {
48336 PyThreadState* __tstate = wxPyBeginAllowThreads();
48337 result = (int)(arg1)->GetFlexibleDirection();
48338 wxPyEndAllowThreads(__tstate);
48339 if (PyErr_Occurred()) SWIG_fail;
48340 }
48341 resultobj = SWIG_From_int(static_cast< int >(result));
48342 return resultobj;
48343 fail:
48344 return NULL;
48345 }
48346
48347
48348 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48349 PyObject *resultobj = 0;
48350 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48351 wxFlexSizerGrowMode arg2 ;
48352 void *argp1 = 0 ;
48353 int res1 = 0 ;
48354 int val2 ;
48355 int ecode2 = 0 ;
48356 PyObject * obj0 = 0 ;
48357 PyObject * obj1 = 0 ;
48358 char * kwnames[] = {
48359 (char *) "self",(char *) "mode", NULL
48360 };
48361
48362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48364 if (!SWIG_IsOK(res1)) {
48365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48366 }
48367 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48368 ecode2 = SWIG_AsVal_int(obj1, &val2);
48369 if (!SWIG_IsOK(ecode2)) {
48370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48371 }
48372 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48373 {
48374 PyThreadState* __tstate = wxPyBeginAllowThreads();
48375 (arg1)->SetNonFlexibleGrowMode(arg2);
48376 wxPyEndAllowThreads(__tstate);
48377 if (PyErr_Occurred()) SWIG_fail;
48378 }
48379 resultobj = SWIG_Py_Void();
48380 return resultobj;
48381 fail:
48382 return NULL;
48383 }
48384
48385
48386 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48387 PyObject *resultobj = 0;
48388 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48389 wxFlexSizerGrowMode result;
48390 void *argp1 = 0 ;
48391 int res1 = 0 ;
48392 PyObject *swig_obj[1] ;
48393
48394 if (!args) SWIG_fail;
48395 swig_obj[0] = args;
48396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48397 if (!SWIG_IsOK(res1)) {
48398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48399 }
48400 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48401 {
48402 PyThreadState* __tstate = wxPyBeginAllowThreads();
48403 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48404 wxPyEndAllowThreads(__tstate);
48405 if (PyErr_Occurred()) SWIG_fail;
48406 }
48407 resultobj = SWIG_From_int(static_cast< int >(result));
48408 return resultobj;
48409 fail:
48410 return NULL;
48411 }
48412
48413
48414 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48415 PyObject *resultobj = 0;
48416 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48417 wxArrayInt *result = 0 ;
48418 void *argp1 = 0 ;
48419 int res1 = 0 ;
48420 PyObject *swig_obj[1] ;
48421
48422 if (!args) SWIG_fail;
48423 swig_obj[0] = args;
48424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48425 if (!SWIG_IsOK(res1)) {
48426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48427 }
48428 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48429 {
48430 PyThreadState* __tstate = wxPyBeginAllowThreads();
48431 {
48432 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48433 result = (wxArrayInt *) &_result_ref;
48434 }
48435 wxPyEndAllowThreads(__tstate);
48436 if (PyErr_Occurred()) SWIG_fail;
48437 }
48438 {
48439 resultobj = PyList_New(0);
48440 size_t idx;
48441 for (idx = 0; idx < result->GetCount(); idx += 1) {
48442 PyObject* val = PyInt_FromLong( result->Item(idx) );
48443 PyList_Append(resultobj, val);
48444 Py_DECREF(val);
48445 }
48446 }
48447 return resultobj;
48448 fail:
48449 return NULL;
48450 }
48451
48452
48453 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48454 PyObject *resultobj = 0;
48455 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48456 wxArrayInt *result = 0 ;
48457 void *argp1 = 0 ;
48458 int res1 = 0 ;
48459 PyObject *swig_obj[1] ;
48460
48461 if (!args) SWIG_fail;
48462 swig_obj[0] = args;
48463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48464 if (!SWIG_IsOK(res1)) {
48465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48466 }
48467 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 {
48471 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48472 result = (wxArrayInt *) &_result_ref;
48473 }
48474 wxPyEndAllowThreads(__tstate);
48475 if (PyErr_Occurred()) SWIG_fail;
48476 }
48477 {
48478 resultobj = PyList_New(0);
48479 size_t idx;
48480 for (idx = 0; idx < result->GetCount(); idx += 1) {
48481 PyObject* val = PyInt_FromLong( result->Item(idx) );
48482 PyList_Append(resultobj, val);
48483 Py_DECREF(val);
48484 }
48485 }
48486 return resultobj;
48487 fail:
48488 return NULL;
48489 }
48490
48491
48492 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48493 PyObject *obj;
48494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48495 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48496 return SWIG_Py_Void();
48497 }
48498
48499 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48500 return SWIG_Python_InitShadowInstance(args);
48501 }
48502
48503 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48504 PyObject *resultobj = 0;
48505 wxStdDialogButtonSizer *result = 0 ;
48506
48507 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48508 {
48509 PyThreadState* __tstate = wxPyBeginAllowThreads();
48510 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48511 wxPyEndAllowThreads(__tstate);
48512 if (PyErr_Occurred()) SWIG_fail;
48513 }
48514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48515 return resultobj;
48516 fail:
48517 return NULL;
48518 }
48519
48520
48521 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48522 PyObject *resultobj = 0;
48523 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48524 wxButton *arg2 = (wxButton *) 0 ;
48525 void *argp1 = 0 ;
48526 int res1 = 0 ;
48527 void *argp2 = 0 ;
48528 int res2 = 0 ;
48529 PyObject * obj0 = 0 ;
48530 PyObject * obj1 = 0 ;
48531 char * kwnames[] = {
48532 (char *) "self",(char *) "button", NULL
48533 };
48534
48535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48537 if (!SWIG_IsOK(res1)) {
48538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48539 }
48540 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48542 if (!SWIG_IsOK(res2)) {
48543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48544 }
48545 arg2 = reinterpret_cast< wxButton * >(argp2);
48546 {
48547 PyThreadState* __tstate = wxPyBeginAllowThreads();
48548 (arg1)->AddButton(arg2);
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 resultobj = SWIG_Py_Void();
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48562 void *argp1 = 0 ;
48563 int res1 = 0 ;
48564 PyObject *swig_obj[1] ;
48565
48566 if (!args) SWIG_fail;
48567 swig_obj[0] = args;
48568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48569 if (!SWIG_IsOK(res1)) {
48570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48571 }
48572 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48573 {
48574 PyThreadState* __tstate = wxPyBeginAllowThreads();
48575 (arg1)->Realize();
48576 wxPyEndAllowThreads(__tstate);
48577 if (PyErr_Occurred()) SWIG_fail;
48578 }
48579 resultobj = SWIG_Py_Void();
48580 return resultobj;
48581 fail:
48582 return NULL;
48583 }
48584
48585
48586 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48587 PyObject *resultobj = 0;
48588 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48589 wxButton *arg2 = (wxButton *) 0 ;
48590 void *argp1 = 0 ;
48591 int res1 = 0 ;
48592 void *argp2 = 0 ;
48593 int res2 = 0 ;
48594 PyObject * obj0 = 0 ;
48595 PyObject * obj1 = 0 ;
48596 char * kwnames[] = {
48597 (char *) "self",(char *) "button", NULL
48598 };
48599
48600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48602 if (!SWIG_IsOK(res1)) {
48603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48604 }
48605 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48607 if (!SWIG_IsOK(res2)) {
48608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48609 }
48610 arg2 = reinterpret_cast< wxButton * >(argp2);
48611 {
48612 PyThreadState* __tstate = wxPyBeginAllowThreads();
48613 (arg1)->SetAffirmativeButton(arg2);
48614 wxPyEndAllowThreads(__tstate);
48615 if (PyErr_Occurred()) SWIG_fail;
48616 }
48617 resultobj = SWIG_Py_Void();
48618 return resultobj;
48619 fail:
48620 return NULL;
48621 }
48622
48623
48624 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48625 PyObject *resultobj = 0;
48626 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48627 wxButton *arg2 = (wxButton *) 0 ;
48628 void *argp1 = 0 ;
48629 int res1 = 0 ;
48630 void *argp2 = 0 ;
48631 int res2 = 0 ;
48632 PyObject * obj0 = 0 ;
48633 PyObject * obj1 = 0 ;
48634 char * kwnames[] = {
48635 (char *) "self",(char *) "button", NULL
48636 };
48637
48638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48640 if (!SWIG_IsOK(res1)) {
48641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48642 }
48643 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48645 if (!SWIG_IsOK(res2)) {
48646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48647 }
48648 arg2 = reinterpret_cast< wxButton * >(argp2);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 (arg1)->SetNegativeButton(arg2);
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 resultobj = SWIG_Py_Void();
48656 return resultobj;
48657 fail:
48658 return NULL;
48659 }
48660
48661
48662 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48663 PyObject *resultobj = 0;
48664 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48665 wxButton *arg2 = (wxButton *) 0 ;
48666 void *argp1 = 0 ;
48667 int res1 = 0 ;
48668 void *argp2 = 0 ;
48669 int res2 = 0 ;
48670 PyObject * obj0 = 0 ;
48671 PyObject * obj1 = 0 ;
48672 char * kwnames[] = {
48673 (char *) "self",(char *) "button", NULL
48674 };
48675
48676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48678 if (!SWIG_IsOK(res1)) {
48679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48680 }
48681 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48682 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48683 if (!SWIG_IsOK(res2)) {
48684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48685 }
48686 arg2 = reinterpret_cast< wxButton * >(argp2);
48687 {
48688 PyThreadState* __tstate = wxPyBeginAllowThreads();
48689 (arg1)->SetCancelButton(arg2);
48690 wxPyEndAllowThreads(__tstate);
48691 if (PyErr_Occurred()) SWIG_fail;
48692 }
48693 resultobj = SWIG_Py_Void();
48694 return resultobj;
48695 fail:
48696 return NULL;
48697 }
48698
48699
48700 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48701 PyObject *resultobj = 0;
48702 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48703 wxButton *result = 0 ;
48704 void *argp1 = 0 ;
48705 int res1 = 0 ;
48706 PyObject *swig_obj[1] ;
48707
48708 if (!args) SWIG_fail;
48709 swig_obj[0] = args;
48710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48711 if (!SWIG_IsOK(res1)) {
48712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48713 }
48714 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48715 {
48716 PyThreadState* __tstate = wxPyBeginAllowThreads();
48717 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48718 wxPyEndAllowThreads(__tstate);
48719 if (PyErr_Occurred()) SWIG_fail;
48720 }
48721 {
48722 resultobj = wxPyMake_wxObject(result, (bool)0);
48723 }
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48731 PyObject *resultobj = 0;
48732 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48733 wxButton *result = 0 ;
48734 void *argp1 = 0 ;
48735 int res1 = 0 ;
48736 PyObject *swig_obj[1] ;
48737
48738 if (!args) SWIG_fail;
48739 swig_obj[0] = args;
48740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48741 if (!SWIG_IsOK(res1)) {
48742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48743 }
48744 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48745 {
48746 PyThreadState* __tstate = wxPyBeginAllowThreads();
48747 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48748 wxPyEndAllowThreads(__tstate);
48749 if (PyErr_Occurred()) SWIG_fail;
48750 }
48751 {
48752 resultobj = wxPyMake_wxObject(result, (bool)0);
48753 }
48754 return resultobj;
48755 fail:
48756 return NULL;
48757 }
48758
48759
48760 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48761 PyObject *resultobj = 0;
48762 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48763 wxButton *result = 0 ;
48764 void *argp1 = 0 ;
48765 int res1 = 0 ;
48766 PyObject *swig_obj[1] ;
48767
48768 if (!args) SWIG_fail;
48769 swig_obj[0] = args;
48770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48771 if (!SWIG_IsOK(res1)) {
48772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48773 }
48774 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 {
48782 resultobj = wxPyMake_wxObject(result, (bool)0);
48783 }
48784 return resultobj;
48785 fail:
48786 return NULL;
48787 }
48788
48789
48790 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48791 PyObject *resultobj = 0;
48792 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48793 wxButton *result = 0 ;
48794 void *argp1 = 0 ;
48795 int res1 = 0 ;
48796 PyObject *swig_obj[1] ;
48797
48798 if (!args) SWIG_fail;
48799 swig_obj[0] = args;
48800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48801 if (!SWIG_IsOK(res1)) {
48802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48803 }
48804 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48805 {
48806 PyThreadState* __tstate = wxPyBeginAllowThreads();
48807 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48808 wxPyEndAllowThreads(__tstate);
48809 if (PyErr_Occurred()) SWIG_fail;
48810 }
48811 {
48812 resultobj = wxPyMake_wxObject(result, (bool)0);
48813 }
48814 return resultobj;
48815 fail:
48816 return NULL;
48817 }
48818
48819
48820 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48821 PyObject *resultobj = 0;
48822 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48823 wxButton *result = 0 ;
48824 void *argp1 = 0 ;
48825 int res1 = 0 ;
48826 PyObject *swig_obj[1] ;
48827
48828 if (!args) SWIG_fail;
48829 swig_obj[0] = args;
48830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48831 if (!SWIG_IsOK(res1)) {
48832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48833 }
48834 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48835 {
48836 PyThreadState* __tstate = wxPyBeginAllowThreads();
48837 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48838 wxPyEndAllowThreads(__tstate);
48839 if (PyErr_Occurred()) SWIG_fail;
48840 }
48841 {
48842 resultobj = wxPyMake_wxObject(result, (bool)0);
48843 }
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48851 PyObject *obj;
48852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48853 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48854 return SWIG_Py_Void();
48855 }
48856
48857 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48858 return SWIG_Python_InitShadowInstance(args);
48859 }
48860
48861 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48862 PyObject *resultobj = 0;
48863 int arg1 = (int) 0 ;
48864 int arg2 = (int) 0 ;
48865 wxGBPosition *result = 0 ;
48866 int val1 ;
48867 int ecode1 = 0 ;
48868 int val2 ;
48869 int ecode2 = 0 ;
48870 PyObject * obj0 = 0 ;
48871 PyObject * obj1 = 0 ;
48872 char * kwnames[] = {
48873 (char *) "row",(char *) "col", NULL
48874 };
48875
48876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48877 if (obj0) {
48878 ecode1 = SWIG_AsVal_int(obj0, &val1);
48879 if (!SWIG_IsOK(ecode1)) {
48880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48881 }
48882 arg1 = static_cast< int >(val1);
48883 }
48884 if (obj1) {
48885 ecode2 = SWIG_AsVal_int(obj1, &val2);
48886 if (!SWIG_IsOK(ecode2)) {
48887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48888 }
48889 arg2 = static_cast< int >(val2);
48890 }
48891 {
48892 PyThreadState* __tstate = wxPyBeginAllowThreads();
48893 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48894 wxPyEndAllowThreads(__tstate);
48895 if (PyErr_Occurred()) SWIG_fail;
48896 }
48897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48898 return resultobj;
48899 fail:
48900 return NULL;
48901 }
48902
48903
48904 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48905 PyObject *resultobj = 0;
48906 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48907 void *argp1 = 0 ;
48908 int res1 = 0 ;
48909 PyObject *swig_obj[1] ;
48910
48911 if (!args) SWIG_fail;
48912 swig_obj[0] = args;
48913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48914 if (!SWIG_IsOK(res1)) {
48915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48916 }
48917 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48918 {
48919 PyThreadState* __tstate = wxPyBeginAllowThreads();
48920 delete arg1;
48921
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_Py_Void();
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 PyObject *resultobj = 0;
48934 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48935 int result;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 PyObject *swig_obj[1] ;
48939
48940 if (!args) SWIG_fail;
48941 swig_obj[0] = args;
48942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48943 if (!SWIG_IsOK(res1)) {
48944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48945 }
48946 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48947 {
48948 PyThreadState* __tstate = wxPyBeginAllowThreads();
48949 result = (int)((wxGBPosition const *)arg1)->GetRow();
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_From_int(static_cast< int >(result));
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48961 PyObject *resultobj = 0;
48962 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48963 int result;
48964 void *argp1 = 0 ;
48965 int res1 = 0 ;
48966 PyObject *swig_obj[1] ;
48967
48968 if (!args) SWIG_fail;
48969 swig_obj[0] = args;
48970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48971 if (!SWIG_IsOK(res1)) {
48972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48973 }
48974 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48975 {
48976 PyThreadState* __tstate = wxPyBeginAllowThreads();
48977 result = (int)((wxGBPosition const *)arg1)->GetCol();
48978 wxPyEndAllowThreads(__tstate);
48979 if (PyErr_Occurred()) SWIG_fail;
48980 }
48981 resultobj = SWIG_From_int(static_cast< int >(result));
48982 return resultobj;
48983 fail:
48984 return NULL;
48985 }
48986
48987
48988 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48989 PyObject *resultobj = 0;
48990 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48991 int arg2 ;
48992 void *argp1 = 0 ;
48993 int res1 = 0 ;
48994 int val2 ;
48995 int ecode2 = 0 ;
48996 PyObject * obj0 = 0 ;
48997 PyObject * obj1 = 0 ;
48998 char * kwnames[] = {
48999 (char *) "self",(char *) "row", NULL
49000 };
49001
49002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49004 if (!SWIG_IsOK(res1)) {
49005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49006 }
49007 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49008 ecode2 = SWIG_AsVal_int(obj1, &val2);
49009 if (!SWIG_IsOK(ecode2)) {
49010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49011 }
49012 arg2 = static_cast< int >(val2);
49013 {
49014 PyThreadState* __tstate = wxPyBeginAllowThreads();
49015 (arg1)->SetRow(arg2);
49016 wxPyEndAllowThreads(__tstate);
49017 if (PyErr_Occurred()) SWIG_fail;
49018 }
49019 resultobj = SWIG_Py_Void();
49020 return resultobj;
49021 fail:
49022 return NULL;
49023 }
49024
49025
49026 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49027 PyObject *resultobj = 0;
49028 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49029 int arg2 ;
49030 void *argp1 = 0 ;
49031 int res1 = 0 ;
49032 int val2 ;
49033 int ecode2 = 0 ;
49034 PyObject * obj0 = 0 ;
49035 PyObject * obj1 = 0 ;
49036 char * kwnames[] = {
49037 (char *) "self",(char *) "col", NULL
49038 };
49039
49040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49042 if (!SWIG_IsOK(res1)) {
49043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49044 }
49045 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49046 ecode2 = SWIG_AsVal_int(obj1, &val2);
49047 if (!SWIG_IsOK(ecode2)) {
49048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49049 }
49050 arg2 = static_cast< int >(val2);
49051 {
49052 PyThreadState* __tstate = wxPyBeginAllowThreads();
49053 (arg1)->SetCol(arg2);
49054 wxPyEndAllowThreads(__tstate);
49055 if (PyErr_Occurred()) SWIG_fail;
49056 }
49057 resultobj = SWIG_Py_Void();
49058 return resultobj;
49059 fail:
49060 return NULL;
49061 }
49062
49063
49064 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49065 PyObject *resultobj = 0;
49066 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49067 PyObject *arg2 = (PyObject *) 0 ;
49068 bool result;
49069 void *argp1 = 0 ;
49070 int res1 = 0 ;
49071 PyObject * obj0 = 0 ;
49072 PyObject * obj1 = 0 ;
49073 char * kwnames[] = {
49074 (char *) "self",(char *) "other", NULL
49075 };
49076
49077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49079 if (!SWIG_IsOK(res1)) {
49080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49081 }
49082 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49083 arg2 = obj1;
49084 {
49085 result = (bool)wxGBPosition___eq__(arg1,arg2);
49086 if (PyErr_Occurred()) SWIG_fail;
49087 }
49088 {
49089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49090 }
49091 return resultobj;
49092 fail:
49093 return NULL;
49094 }
49095
49096
49097 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49098 PyObject *resultobj = 0;
49099 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49100 PyObject *arg2 = (PyObject *) 0 ;
49101 bool result;
49102 void *argp1 = 0 ;
49103 int res1 = 0 ;
49104 PyObject * obj0 = 0 ;
49105 PyObject * obj1 = 0 ;
49106 char * kwnames[] = {
49107 (char *) "self",(char *) "other", NULL
49108 };
49109
49110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49112 if (!SWIG_IsOK(res1)) {
49113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49114 }
49115 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49116 arg2 = obj1;
49117 {
49118 result = (bool)wxGBPosition___ne__(arg1,arg2);
49119 if (PyErr_Occurred()) SWIG_fail;
49120 }
49121 {
49122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49123 }
49124 return resultobj;
49125 fail:
49126 return NULL;
49127 }
49128
49129
49130 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49131 PyObject *resultobj = 0;
49132 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49133 int arg2 = (int) 0 ;
49134 int arg3 = (int) 0 ;
49135 void *argp1 = 0 ;
49136 int res1 = 0 ;
49137 int val2 ;
49138 int ecode2 = 0 ;
49139 int val3 ;
49140 int ecode3 = 0 ;
49141 PyObject * obj0 = 0 ;
49142 PyObject * obj1 = 0 ;
49143 PyObject * obj2 = 0 ;
49144 char * kwnames[] = {
49145 (char *) "self",(char *) "row",(char *) "col", NULL
49146 };
49147
49148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49150 if (!SWIG_IsOK(res1)) {
49151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49152 }
49153 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49154 if (obj1) {
49155 ecode2 = SWIG_AsVal_int(obj1, &val2);
49156 if (!SWIG_IsOK(ecode2)) {
49157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49158 }
49159 arg2 = static_cast< int >(val2);
49160 }
49161 if (obj2) {
49162 ecode3 = SWIG_AsVal_int(obj2, &val3);
49163 if (!SWIG_IsOK(ecode3)) {
49164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49165 }
49166 arg3 = static_cast< int >(val3);
49167 }
49168 {
49169 PyThreadState* __tstate = wxPyBeginAllowThreads();
49170 wxGBPosition_Set(arg1,arg2,arg3);
49171 wxPyEndAllowThreads(__tstate);
49172 if (PyErr_Occurred()) SWIG_fail;
49173 }
49174 resultobj = SWIG_Py_Void();
49175 return resultobj;
49176 fail:
49177 return NULL;
49178 }
49179
49180
49181 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49182 PyObject *resultobj = 0;
49183 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49184 PyObject *result = 0 ;
49185 void *argp1 = 0 ;
49186 int res1 = 0 ;
49187 PyObject *swig_obj[1] ;
49188
49189 if (!args) SWIG_fail;
49190 swig_obj[0] = args;
49191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49192 if (!SWIG_IsOK(res1)) {
49193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49194 }
49195 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49196 {
49197 PyThreadState* __tstate = wxPyBeginAllowThreads();
49198 result = (PyObject *)wxGBPosition_Get(arg1);
49199 wxPyEndAllowThreads(__tstate);
49200 if (PyErr_Occurred()) SWIG_fail;
49201 }
49202 resultobj = result;
49203 return resultobj;
49204 fail:
49205 return NULL;
49206 }
49207
49208
49209 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49210 PyObject *obj;
49211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49212 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49213 return SWIG_Py_Void();
49214 }
49215
49216 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49217 return SWIG_Python_InitShadowInstance(args);
49218 }
49219
49220 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49221 PyObject *resultobj = 0;
49222 int arg1 = (int) 1 ;
49223 int arg2 = (int) 1 ;
49224 wxGBSpan *result = 0 ;
49225 int val1 ;
49226 int ecode1 = 0 ;
49227 int val2 ;
49228 int ecode2 = 0 ;
49229 PyObject * obj0 = 0 ;
49230 PyObject * obj1 = 0 ;
49231 char * kwnames[] = {
49232 (char *) "rowspan",(char *) "colspan", NULL
49233 };
49234
49235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49236 if (obj0) {
49237 ecode1 = SWIG_AsVal_int(obj0, &val1);
49238 if (!SWIG_IsOK(ecode1)) {
49239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49240 }
49241 arg1 = static_cast< int >(val1);
49242 }
49243 if (obj1) {
49244 ecode2 = SWIG_AsVal_int(obj1, &val2);
49245 if (!SWIG_IsOK(ecode2)) {
49246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49247 }
49248 arg2 = static_cast< int >(val2);
49249 }
49250 {
49251 PyThreadState* __tstate = wxPyBeginAllowThreads();
49252 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49253 wxPyEndAllowThreads(__tstate);
49254 if (PyErr_Occurred()) SWIG_fail;
49255 }
49256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49257 return resultobj;
49258 fail:
49259 return NULL;
49260 }
49261
49262
49263 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49264 PyObject *resultobj = 0;
49265 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49266 void *argp1 = 0 ;
49267 int res1 = 0 ;
49268 PyObject *swig_obj[1] ;
49269
49270 if (!args) SWIG_fail;
49271 swig_obj[0] = args;
49272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49273 if (!SWIG_IsOK(res1)) {
49274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49275 }
49276 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49277 {
49278 PyThreadState* __tstate = wxPyBeginAllowThreads();
49279 delete arg1;
49280
49281 wxPyEndAllowThreads(__tstate);
49282 if (PyErr_Occurred()) SWIG_fail;
49283 }
49284 resultobj = SWIG_Py_Void();
49285 return resultobj;
49286 fail:
49287 return NULL;
49288 }
49289
49290
49291 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49292 PyObject *resultobj = 0;
49293 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49294 int result;
49295 void *argp1 = 0 ;
49296 int res1 = 0 ;
49297 PyObject *swig_obj[1] ;
49298
49299 if (!args) SWIG_fail;
49300 swig_obj[0] = args;
49301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49302 if (!SWIG_IsOK(res1)) {
49303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49304 }
49305 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49306 {
49307 PyThreadState* __tstate = wxPyBeginAllowThreads();
49308 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49309 wxPyEndAllowThreads(__tstate);
49310 if (PyErr_Occurred()) SWIG_fail;
49311 }
49312 resultobj = SWIG_From_int(static_cast< int >(result));
49313 return resultobj;
49314 fail:
49315 return NULL;
49316 }
49317
49318
49319 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49320 PyObject *resultobj = 0;
49321 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49322 int result;
49323 void *argp1 = 0 ;
49324 int res1 = 0 ;
49325 PyObject *swig_obj[1] ;
49326
49327 if (!args) SWIG_fail;
49328 swig_obj[0] = args;
49329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49330 if (!SWIG_IsOK(res1)) {
49331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49332 }
49333 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49334 {
49335 PyThreadState* __tstate = wxPyBeginAllowThreads();
49336 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49337 wxPyEndAllowThreads(__tstate);
49338 if (PyErr_Occurred()) SWIG_fail;
49339 }
49340 resultobj = SWIG_From_int(static_cast< int >(result));
49341 return resultobj;
49342 fail:
49343 return NULL;
49344 }
49345
49346
49347 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49348 PyObject *resultobj = 0;
49349 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49350 int arg2 ;
49351 void *argp1 = 0 ;
49352 int res1 = 0 ;
49353 int val2 ;
49354 int ecode2 = 0 ;
49355 PyObject * obj0 = 0 ;
49356 PyObject * obj1 = 0 ;
49357 char * kwnames[] = {
49358 (char *) "self",(char *) "rowspan", NULL
49359 };
49360
49361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49363 if (!SWIG_IsOK(res1)) {
49364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49365 }
49366 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49367 ecode2 = SWIG_AsVal_int(obj1, &val2);
49368 if (!SWIG_IsOK(ecode2)) {
49369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49370 }
49371 arg2 = static_cast< int >(val2);
49372 {
49373 PyThreadState* __tstate = wxPyBeginAllowThreads();
49374 (arg1)->SetRowspan(arg2);
49375 wxPyEndAllowThreads(__tstate);
49376 if (PyErr_Occurred()) SWIG_fail;
49377 }
49378 resultobj = SWIG_Py_Void();
49379 return resultobj;
49380 fail:
49381 return NULL;
49382 }
49383
49384
49385 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49386 PyObject *resultobj = 0;
49387 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49388 int arg2 ;
49389 void *argp1 = 0 ;
49390 int res1 = 0 ;
49391 int val2 ;
49392 int ecode2 = 0 ;
49393 PyObject * obj0 = 0 ;
49394 PyObject * obj1 = 0 ;
49395 char * kwnames[] = {
49396 (char *) "self",(char *) "colspan", NULL
49397 };
49398
49399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49401 if (!SWIG_IsOK(res1)) {
49402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49403 }
49404 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49405 ecode2 = SWIG_AsVal_int(obj1, &val2);
49406 if (!SWIG_IsOK(ecode2)) {
49407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49408 }
49409 arg2 = static_cast< int >(val2);
49410 {
49411 PyThreadState* __tstate = wxPyBeginAllowThreads();
49412 (arg1)->SetColspan(arg2);
49413 wxPyEndAllowThreads(__tstate);
49414 if (PyErr_Occurred()) SWIG_fail;
49415 }
49416 resultobj = SWIG_Py_Void();
49417 return resultobj;
49418 fail:
49419 return NULL;
49420 }
49421
49422
49423 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49424 PyObject *resultobj = 0;
49425 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49426 PyObject *arg2 = (PyObject *) 0 ;
49427 bool result;
49428 void *argp1 = 0 ;
49429 int res1 = 0 ;
49430 PyObject * obj0 = 0 ;
49431 PyObject * obj1 = 0 ;
49432 char * kwnames[] = {
49433 (char *) "self",(char *) "other", NULL
49434 };
49435
49436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49438 if (!SWIG_IsOK(res1)) {
49439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49440 }
49441 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49442 arg2 = obj1;
49443 {
49444 result = (bool)wxGBSpan___eq__(arg1,arg2);
49445 if (PyErr_Occurred()) SWIG_fail;
49446 }
49447 {
49448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49449 }
49450 return resultobj;
49451 fail:
49452 return NULL;
49453 }
49454
49455
49456 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49457 PyObject *resultobj = 0;
49458 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49459 PyObject *arg2 = (PyObject *) 0 ;
49460 bool result;
49461 void *argp1 = 0 ;
49462 int res1 = 0 ;
49463 PyObject * obj0 = 0 ;
49464 PyObject * obj1 = 0 ;
49465 char * kwnames[] = {
49466 (char *) "self",(char *) "other", NULL
49467 };
49468
49469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49471 if (!SWIG_IsOK(res1)) {
49472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49473 }
49474 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49475 arg2 = obj1;
49476 {
49477 result = (bool)wxGBSpan___ne__(arg1,arg2);
49478 if (PyErr_Occurred()) SWIG_fail;
49479 }
49480 {
49481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49482 }
49483 return resultobj;
49484 fail:
49485 return NULL;
49486 }
49487
49488
49489 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49490 PyObject *resultobj = 0;
49491 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49492 int arg2 = (int) 1 ;
49493 int arg3 = (int) 1 ;
49494 void *argp1 = 0 ;
49495 int res1 = 0 ;
49496 int val2 ;
49497 int ecode2 = 0 ;
49498 int val3 ;
49499 int ecode3 = 0 ;
49500 PyObject * obj0 = 0 ;
49501 PyObject * obj1 = 0 ;
49502 PyObject * obj2 = 0 ;
49503 char * kwnames[] = {
49504 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49505 };
49506
49507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49509 if (!SWIG_IsOK(res1)) {
49510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49511 }
49512 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49513 if (obj1) {
49514 ecode2 = SWIG_AsVal_int(obj1, &val2);
49515 if (!SWIG_IsOK(ecode2)) {
49516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49517 }
49518 arg2 = static_cast< int >(val2);
49519 }
49520 if (obj2) {
49521 ecode3 = SWIG_AsVal_int(obj2, &val3);
49522 if (!SWIG_IsOK(ecode3)) {
49523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49524 }
49525 arg3 = static_cast< int >(val3);
49526 }
49527 {
49528 PyThreadState* __tstate = wxPyBeginAllowThreads();
49529 wxGBSpan_Set(arg1,arg2,arg3);
49530 wxPyEndAllowThreads(__tstate);
49531 if (PyErr_Occurred()) SWIG_fail;
49532 }
49533 resultobj = SWIG_Py_Void();
49534 return resultobj;
49535 fail:
49536 return NULL;
49537 }
49538
49539
49540 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49541 PyObject *resultobj = 0;
49542 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49543 PyObject *result = 0 ;
49544 void *argp1 = 0 ;
49545 int res1 = 0 ;
49546 PyObject *swig_obj[1] ;
49547
49548 if (!args) SWIG_fail;
49549 swig_obj[0] = args;
49550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49551 if (!SWIG_IsOK(res1)) {
49552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49553 }
49554 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49555 {
49556 PyThreadState* __tstate = wxPyBeginAllowThreads();
49557 result = (PyObject *)wxGBSpan_Get(arg1);
49558 wxPyEndAllowThreads(__tstate);
49559 if (PyErr_Occurred()) SWIG_fail;
49560 }
49561 resultobj = result;
49562 return resultobj;
49563 fail:
49564 return NULL;
49565 }
49566
49567
49568 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49569 PyObject *obj;
49570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49571 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49572 return SWIG_Py_Void();
49573 }
49574
49575 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49576 return SWIG_Python_InitShadowInstance(args);
49577 }
49578
49579 SWIGINTERN int DefaultSpan_set(PyObject *) {
49580 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49581 return 1;
49582 }
49583
49584
49585 SWIGINTERN PyObject *DefaultSpan_get(void) {
49586 PyObject *pyobj = 0;
49587
49588 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49589 return pyobj;
49590 }
49591
49592
49593 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49594 PyObject *resultobj = 0;
49595 wxGBSizerItem *result = 0 ;
49596
49597 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49598 {
49599 PyThreadState* __tstate = wxPyBeginAllowThreads();
49600 result = (wxGBSizerItem *)new wxGBSizerItem();
49601 wxPyEndAllowThreads(__tstate);
49602 if (PyErr_Occurred()) SWIG_fail;
49603 }
49604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49605 return resultobj;
49606 fail:
49607 return NULL;
49608 }
49609
49610
49611 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49612 PyObject *resultobj = 0;
49613 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49614 void *argp1 = 0 ;
49615 int res1 = 0 ;
49616 PyObject *swig_obj[1] ;
49617
49618 if (!args) SWIG_fail;
49619 swig_obj[0] = args;
49620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49621 if (!SWIG_IsOK(res1)) {
49622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49623 }
49624 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49625 {
49626 PyThreadState* __tstate = wxPyBeginAllowThreads();
49627 delete arg1;
49628
49629 wxPyEndAllowThreads(__tstate);
49630 if (PyErr_Occurred()) SWIG_fail;
49631 }
49632 resultobj = SWIG_Py_Void();
49633 return resultobj;
49634 fail:
49635 return NULL;
49636 }
49637
49638
49639 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49640 PyObject *resultobj = 0;
49641 wxWindow *arg1 = (wxWindow *) 0 ;
49642 wxGBPosition *arg2 = 0 ;
49643 wxGBSpan *arg3 = 0 ;
49644 int arg4 ;
49645 int arg5 ;
49646 PyObject *arg6 = (PyObject *) NULL ;
49647 wxGBSizerItem *result = 0 ;
49648 void *argp1 = 0 ;
49649 int res1 = 0 ;
49650 wxGBPosition temp2 ;
49651 wxGBSpan temp3 ;
49652 int val4 ;
49653 int ecode4 = 0 ;
49654 int val5 ;
49655 int ecode5 = 0 ;
49656 PyObject * obj0 = 0 ;
49657 PyObject * obj1 = 0 ;
49658 PyObject * obj2 = 0 ;
49659 PyObject * obj3 = 0 ;
49660 PyObject * obj4 = 0 ;
49661 PyObject * obj5 = 0 ;
49662 char * kwnames[] = {
49663 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49664 };
49665
49666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49668 if (!SWIG_IsOK(res1)) {
49669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49670 }
49671 arg1 = reinterpret_cast< wxWindow * >(argp1);
49672 {
49673 arg2 = &temp2;
49674 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49675 }
49676 {
49677 arg3 = &temp3;
49678 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49679 }
49680 ecode4 = SWIG_AsVal_int(obj3, &val4);
49681 if (!SWIG_IsOK(ecode4)) {
49682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49683 }
49684 arg4 = static_cast< int >(val4);
49685 ecode5 = SWIG_AsVal_int(obj4, &val5);
49686 if (!SWIG_IsOK(ecode5)) {
49687 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49688 }
49689 arg5 = static_cast< int >(val5);
49690 if (obj5) {
49691 arg6 = obj5;
49692 }
49693 {
49694 PyThreadState* __tstate = wxPyBeginAllowThreads();
49695 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49696 wxPyEndAllowThreads(__tstate);
49697 if (PyErr_Occurred()) SWIG_fail;
49698 }
49699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49700 return resultobj;
49701 fail:
49702 return NULL;
49703 }
49704
49705
49706 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49707 PyObject *resultobj = 0;
49708 wxSizer *arg1 = (wxSizer *) 0 ;
49709 wxGBPosition *arg2 = 0 ;
49710 wxGBSpan *arg3 = 0 ;
49711 int arg4 ;
49712 int arg5 ;
49713 PyObject *arg6 = (PyObject *) NULL ;
49714 wxGBSizerItem *result = 0 ;
49715 int res1 = 0 ;
49716 wxGBPosition temp2 ;
49717 wxGBSpan temp3 ;
49718 int val4 ;
49719 int ecode4 = 0 ;
49720 int val5 ;
49721 int ecode5 = 0 ;
49722 PyObject * obj0 = 0 ;
49723 PyObject * obj1 = 0 ;
49724 PyObject * obj2 = 0 ;
49725 PyObject * obj3 = 0 ;
49726 PyObject * obj4 = 0 ;
49727 PyObject * obj5 = 0 ;
49728 char * kwnames[] = {
49729 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49730 };
49731
49732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49733 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49734 if (!SWIG_IsOK(res1)) {
49735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49736 }
49737 {
49738 arg2 = &temp2;
49739 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49740 }
49741 {
49742 arg3 = &temp3;
49743 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49744 }
49745 ecode4 = SWIG_AsVal_int(obj3, &val4);
49746 if (!SWIG_IsOK(ecode4)) {
49747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49748 }
49749 arg4 = static_cast< int >(val4);
49750 ecode5 = SWIG_AsVal_int(obj4, &val5);
49751 if (!SWIG_IsOK(ecode5)) {
49752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49753 }
49754 arg5 = static_cast< int >(val5);
49755 if (obj5) {
49756 arg6 = obj5;
49757 }
49758 {
49759 PyThreadState* __tstate = wxPyBeginAllowThreads();
49760 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49761 wxPyEndAllowThreads(__tstate);
49762 if (PyErr_Occurred()) SWIG_fail;
49763 }
49764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49765 return resultobj;
49766 fail:
49767 return NULL;
49768 }
49769
49770
49771 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49772 PyObject *resultobj = 0;
49773 int arg1 ;
49774 int arg2 ;
49775 wxGBPosition *arg3 = 0 ;
49776 wxGBSpan *arg4 = 0 ;
49777 int arg5 ;
49778 int arg6 ;
49779 PyObject *arg7 = (PyObject *) NULL ;
49780 wxGBSizerItem *result = 0 ;
49781 int val1 ;
49782 int ecode1 = 0 ;
49783 int val2 ;
49784 int ecode2 = 0 ;
49785 wxGBPosition temp3 ;
49786 wxGBSpan temp4 ;
49787 int val5 ;
49788 int ecode5 = 0 ;
49789 int val6 ;
49790 int ecode6 = 0 ;
49791 PyObject * obj0 = 0 ;
49792 PyObject * obj1 = 0 ;
49793 PyObject * obj2 = 0 ;
49794 PyObject * obj3 = 0 ;
49795 PyObject * obj4 = 0 ;
49796 PyObject * obj5 = 0 ;
49797 PyObject * obj6 = 0 ;
49798 char * kwnames[] = {
49799 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49800 };
49801
49802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49803 ecode1 = SWIG_AsVal_int(obj0, &val1);
49804 if (!SWIG_IsOK(ecode1)) {
49805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49806 }
49807 arg1 = static_cast< int >(val1);
49808 ecode2 = SWIG_AsVal_int(obj1, &val2);
49809 if (!SWIG_IsOK(ecode2)) {
49810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49811 }
49812 arg2 = static_cast< int >(val2);
49813 {
49814 arg3 = &temp3;
49815 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49816 }
49817 {
49818 arg4 = &temp4;
49819 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49820 }
49821 ecode5 = SWIG_AsVal_int(obj4, &val5);
49822 if (!SWIG_IsOK(ecode5)) {
49823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49824 }
49825 arg5 = static_cast< int >(val5);
49826 ecode6 = SWIG_AsVal_int(obj5, &val6);
49827 if (!SWIG_IsOK(ecode6)) {
49828 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49829 }
49830 arg6 = static_cast< int >(val6);
49831 if (obj6) {
49832 arg7 = obj6;
49833 }
49834 {
49835 PyThreadState* __tstate = wxPyBeginAllowThreads();
49836 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49837 wxPyEndAllowThreads(__tstate);
49838 if (PyErr_Occurred()) SWIG_fail;
49839 }
49840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49841 return resultobj;
49842 fail:
49843 return NULL;
49844 }
49845
49846
49847 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49848 PyObject *resultobj = 0;
49849 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49850 wxGBPosition result;
49851 void *argp1 = 0 ;
49852 int res1 = 0 ;
49853 PyObject *swig_obj[1] ;
49854
49855 if (!args) SWIG_fail;
49856 swig_obj[0] = args;
49857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49858 if (!SWIG_IsOK(res1)) {
49859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49860 }
49861 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49862 {
49863 PyThreadState* __tstate = wxPyBeginAllowThreads();
49864 result = ((wxGBSizerItem const *)arg1)->GetPos();
49865 wxPyEndAllowThreads(__tstate);
49866 if (PyErr_Occurred()) SWIG_fail;
49867 }
49868 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49869 return resultobj;
49870 fail:
49871 return NULL;
49872 }
49873
49874
49875 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49876 PyObject *resultobj = 0;
49877 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49878 wxGBSpan result;
49879 void *argp1 = 0 ;
49880 int res1 = 0 ;
49881 PyObject *swig_obj[1] ;
49882
49883 if (!args) SWIG_fail;
49884 swig_obj[0] = args;
49885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49886 if (!SWIG_IsOK(res1)) {
49887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49888 }
49889 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49890 {
49891 PyThreadState* __tstate = wxPyBeginAllowThreads();
49892 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49893 wxPyEndAllowThreads(__tstate);
49894 if (PyErr_Occurred()) SWIG_fail;
49895 }
49896 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49897 return resultobj;
49898 fail:
49899 return NULL;
49900 }
49901
49902
49903 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49904 PyObject *resultobj = 0;
49905 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49906 wxGBPosition *arg2 = 0 ;
49907 bool result;
49908 void *argp1 = 0 ;
49909 int res1 = 0 ;
49910 wxGBPosition temp2 ;
49911 PyObject * obj0 = 0 ;
49912 PyObject * obj1 = 0 ;
49913 char * kwnames[] = {
49914 (char *) "self",(char *) "pos", NULL
49915 };
49916
49917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49919 if (!SWIG_IsOK(res1)) {
49920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49921 }
49922 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49923 {
49924 arg2 = &temp2;
49925 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49926 }
49927 {
49928 PyThreadState* __tstate = wxPyBeginAllowThreads();
49929 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49930 wxPyEndAllowThreads(__tstate);
49931 if (PyErr_Occurred()) SWIG_fail;
49932 }
49933 {
49934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49935 }
49936 return resultobj;
49937 fail:
49938 return NULL;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49943 PyObject *resultobj = 0;
49944 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49945 wxGBSpan *arg2 = 0 ;
49946 bool result;
49947 void *argp1 = 0 ;
49948 int res1 = 0 ;
49949 wxGBSpan temp2 ;
49950 PyObject * obj0 = 0 ;
49951 PyObject * obj1 = 0 ;
49952 char * kwnames[] = {
49953 (char *) "self",(char *) "span", NULL
49954 };
49955
49956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49958 if (!SWIG_IsOK(res1)) {
49959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49960 }
49961 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49962 {
49963 arg2 = &temp2;
49964 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49965 }
49966 {
49967 PyThreadState* __tstate = wxPyBeginAllowThreads();
49968 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49969 wxPyEndAllowThreads(__tstate);
49970 if (PyErr_Occurred()) SWIG_fail;
49971 }
49972 {
49973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49974 }
49975 return resultobj;
49976 fail:
49977 return NULL;
49978 }
49979
49980
49981 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49982 PyObject *resultobj = 0;
49983 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49984 wxGBSizerItem *arg2 = 0 ;
49985 bool result;
49986 void *argp1 = 0 ;
49987 int res1 = 0 ;
49988 void *argp2 = 0 ;
49989 int res2 = 0 ;
49990 PyObject * obj0 = 0 ;
49991 PyObject * obj1 = 0 ;
49992 char * kwnames[] = {
49993 (char *) "self",(char *) "other", NULL
49994 };
49995
49996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49998 if (!SWIG_IsOK(res1)) {
49999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50000 }
50001 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50002 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50003 if (!SWIG_IsOK(res2)) {
50004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50005 }
50006 if (!argp2) {
50007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50008 }
50009 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50010 {
50011 PyThreadState* __tstate = wxPyBeginAllowThreads();
50012 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50013 wxPyEndAllowThreads(__tstate);
50014 if (PyErr_Occurred()) SWIG_fail;
50015 }
50016 {
50017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50018 }
50019 return resultobj;
50020 fail:
50021 return NULL;
50022 }
50023
50024
50025 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50026 PyObject *resultobj = 0;
50027 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50028 wxGBPosition *arg2 = 0 ;
50029 wxGBSpan *arg3 = 0 ;
50030 bool result;
50031 void *argp1 = 0 ;
50032 int res1 = 0 ;
50033 wxGBPosition temp2 ;
50034 wxGBSpan temp3 ;
50035 PyObject * obj0 = 0 ;
50036 PyObject * obj1 = 0 ;
50037 PyObject * obj2 = 0 ;
50038 char * kwnames[] = {
50039 (char *) "self",(char *) "pos",(char *) "span", NULL
50040 };
50041
50042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50044 if (!SWIG_IsOK(res1)) {
50045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50046 }
50047 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50048 {
50049 arg2 = &temp2;
50050 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50051 }
50052 {
50053 arg3 = &temp3;
50054 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50055 }
50056 {
50057 PyThreadState* __tstate = wxPyBeginAllowThreads();
50058 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50059 wxPyEndAllowThreads(__tstate);
50060 if (PyErr_Occurred()) SWIG_fail;
50061 }
50062 {
50063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50064 }
50065 return resultobj;
50066 fail:
50067 return NULL;
50068 }
50069
50070
50071 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50072 PyObject *resultobj = 0;
50073 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50074 wxGBPosition result;
50075 void *argp1 = 0 ;
50076 int res1 = 0 ;
50077 PyObject *swig_obj[1] ;
50078
50079 if (!args) SWIG_fail;
50080 swig_obj[0] = args;
50081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50082 if (!SWIG_IsOK(res1)) {
50083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50084 }
50085 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50086 {
50087 PyThreadState* __tstate = wxPyBeginAllowThreads();
50088 result = wxGBSizerItem_GetEndPos(arg1);
50089 wxPyEndAllowThreads(__tstate);
50090 if (PyErr_Occurred()) SWIG_fail;
50091 }
50092 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50093 return resultobj;
50094 fail:
50095 return NULL;
50096 }
50097
50098
50099 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50100 PyObject *resultobj = 0;
50101 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50102 wxGridBagSizer *result = 0 ;
50103 void *argp1 = 0 ;
50104 int res1 = 0 ;
50105 PyObject *swig_obj[1] ;
50106
50107 if (!args) SWIG_fail;
50108 swig_obj[0] = args;
50109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50110 if (!SWIG_IsOK(res1)) {
50111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50112 }
50113 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50114 {
50115 PyThreadState* __tstate = wxPyBeginAllowThreads();
50116 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50117 wxPyEndAllowThreads(__tstate);
50118 if (PyErr_Occurred()) SWIG_fail;
50119 }
50120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50128 PyObject *resultobj = 0;
50129 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50130 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 void *argp2 = 0 ;
50134 int res2 = 0 ;
50135 PyObject * obj0 = 0 ;
50136 PyObject * obj1 = 0 ;
50137 char * kwnames[] = {
50138 (char *) "self",(char *) "sizer", NULL
50139 };
50140
50141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50143 if (!SWIG_IsOK(res1)) {
50144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50145 }
50146 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50148 if (!SWIG_IsOK(res2)) {
50149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50150 }
50151 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50152 {
50153 PyThreadState* __tstate = wxPyBeginAllowThreads();
50154 (arg1)->SetGBSizer(arg2);
50155 wxPyEndAllowThreads(__tstate);
50156 if (PyErr_Occurred()) SWIG_fail;
50157 }
50158 resultobj = SWIG_Py_Void();
50159 return resultobj;
50160 fail:
50161 return NULL;
50162 }
50163
50164
50165 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50166 PyObject *obj;
50167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50168 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50169 return SWIG_Py_Void();
50170 }
50171
50172 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50173 return SWIG_Python_InitShadowInstance(args);
50174 }
50175
50176 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50177 PyObject *resultobj = 0;
50178 int arg1 = (int) 0 ;
50179 int arg2 = (int) 0 ;
50180 wxGridBagSizer *result = 0 ;
50181 int val1 ;
50182 int ecode1 = 0 ;
50183 int val2 ;
50184 int ecode2 = 0 ;
50185 PyObject * obj0 = 0 ;
50186 PyObject * obj1 = 0 ;
50187 char * kwnames[] = {
50188 (char *) "vgap",(char *) "hgap", NULL
50189 };
50190
50191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50192 if (obj0) {
50193 ecode1 = SWIG_AsVal_int(obj0, &val1);
50194 if (!SWIG_IsOK(ecode1)) {
50195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50196 }
50197 arg1 = static_cast< int >(val1);
50198 }
50199 if (obj1) {
50200 ecode2 = SWIG_AsVal_int(obj1, &val2);
50201 if (!SWIG_IsOK(ecode2)) {
50202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50203 }
50204 arg2 = static_cast< int >(val2);
50205 }
50206 {
50207 PyThreadState* __tstate = wxPyBeginAllowThreads();
50208 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50209 wxPyEndAllowThreads(__tstate);
50210 if (PyErr_Occurred()) SWIG_fail;
50211 }
50212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50213 return resultobj;
50214 fail:
50215 return NULL;
50216 }
50217
50218
50219 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50220 PyObject *resultobj = 0;
50221 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50222 PyObject *arg2 = (PyObject *) 0 ;
50223 wxGBPosition *arg3 = 0 ;
50224 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50225 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50226 int arg5 = (int) 0 ;
50227 int arg6 = (int) 0 ;
50228 PyObject *arg7 = (PyObject *) NULL ;
50229 wxGBSizerItem *result = 0 ;
50230 void *argp1 = 0 ;
50231 int res1 = 0 ;
50232 wxGBPosition temp3 ;
50233 wxGBSpan temp4 ;
50234 int val5 ;
50235 int ecode5 = 0 ;
50236 int val6 ;
50237 int ecode6 = 0 ;
50238 PyObject * obj0 = 0 ;
50239 PyObject * obj1 = 0 ;
50240 PyObject * obj2 = 0 ;
50241 PyObject * obj3 = 0 ;
50242 PyObject * obj4 = 0 ;
50243 PyObject * obj5 = 0 ;
50244 PyObject * obj6 = 0 ;
50245 char * kwnames[] = {
50246 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50247 };
50248
50249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50251 if (!SWIG_IsOK(res1)) {
50252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50253 }
50254 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50255 arg2 = obj1;
50256 {
50257 arg3 = &temp3;
50258 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50259 }
50260 if (obj3) {
50261 {
50262 arg4 = &temp4;
50263 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50264 }
50265 }
50266 if (obj4) {
50267 ecode5 = SWIG_AsVal_int(obj4, &val5);
50268 if (!SWIG_IsOK(ecode5)) {
50269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50270 }
50271 arg5 = static_cast< int >(val5);
50272 }
50273 if (obj5) {
50274 ecode6 = SWIG_AsVal_int(obj5, &val6);
50275 if (!SWIG_IsOK(ecode6)) {
50276 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50277 }
50278 arg6 = static_cast< int >(val6);
50279 }
50280 if (obj6) {
50281 arg7 = obj6;
50282 }
50283 {
50284 PyThreadState* __tstate = wxPyBeginAllowThreads();
50285 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50286 wxPyEndAllowThreads(__tstate);
50287 if (PyErr_Occurred()) SWIG_fail;
50288 }
50289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50290 return resultobj;
50291 fail:
50292 return NULL;
50293 }
50294
50295
50296 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50297 PyObject *resultobj = 0;
50298 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50299 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50300 wxGBSizerItem *result = 0 ;
50301 void *argp1 = 0 ;
50302 int res1 = 0 ;
50303 int res2 = 0 ;
50304 PyObject * obj0 = 0 ;
50305 PyObject * obj1 = 0 ;
50306 char * kwnames[] = {
50307 (char *) "self",(char *) "item", NULL
50308 };
50309
50310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50312 if (!SWIG_IsOK(res1)) {
50313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50314 }
50315 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50316 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50317 if (!SWIG_IsOK(res2)) {
50318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50319 }
50320 {
50321 PyThreadState* __tstate = wxPyBeginAllowThreads();
50322 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50323 wxPyEndAllowThreads(__tstate);
50324 if (PyErr_Occurred()) SWIG_fail;
50325 }
50326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50327 return resultobj;
50328 fail:
50329 return NULL;
50330 }
50331
50332
50333 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50334 PyObject *resultobj = 0;
50335 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50336 int arg2 ;
50337 int arg3 ;
50338 wxSize result;
50339 void *argp1 = 0 ;
50340 int res1 = 0 ;
50341 int val2 ;
50342 int ecode2 = 0 ;
50343 int val3 ;
50344 int ecode3 = 0 ;
50345 PyObject * obj0 = 0 ;
50346 PyObject * obj1 = 0 ;
50347 PyObject * obj2 = 0 ;
50348 char * kwnames[] = {
50349 (char *) "self",(char *) "row",(char *) "col", NULL
50350 };
50351
50352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50354 if (!SWIG_IsOK(res1)) {
50355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50356 }
50357 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50358 ecode2 = SWIG_AsVal_int(obj1, &val2);
50359 if (!SWIG_IsOK(ecode2)) {
50360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50361 }
50362 arg2 = static_cast< int >(val2);
50363 ecode3 = SWIG_AsVal_int(obj2, &val3);
50364 if (!SWIG_IsOK(ecode3)) {
50365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50366 }
50367 arg3 = static_cast< int >(val3);
50368 {
50369 PyThreadState* __tstate = wxPyBeginAllowThreads();
50370 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50371 wxPyEndAllowThreads(__tstate);
50372 if (PyErr_Occurred()) SWIG_fail;
50373 }
50374 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50375 return resultobj;
50376 fail:
50377 return NULL;
50378 }
50379
50380
50381 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50382 PyObject *resultobj = 0;
50383 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50384 wxSize result;
50385 void *argp1 = 0 ;
50386 int res1 = 0 ;
50387 PyObject *swig_obj[1] ;
50388
50389 if (!args) SWIG_fail;
50390 swig_obj[0] = args;
50391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50394 }
50395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50396 {
50397 PyThreadState* __tstate = wxPyBeginAllowThreads();
50398 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50399 wxPyEndAllowThreads(__tstate);
50400 if (PyErr_Occurred()) SWIG_fail;
50401 }
50402 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50403 return resultobj;
50404 fail:
50405 return NULL;
50406 }
50407
50408
50409 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50410 PyObject *resultobj = 0;
50411 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50412 wxSize *arg2 = 0 ;
50413 void *argp1 = 0 ;
50414 int res1 = 0 ;
50415 wxSize temp2 ;
50416 PyObject * obj0 = 0 ;
50417 PyObject * obj1 = 0 ;
50418 char * kwnames[] = {
50419 (char *) "self",(char *) "sz", NULL
50420 };
50421
50422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50428 {
50429 arg2 = &temp2;
50430 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50431 }
50432 {
50433 PyThreadState* __tstate = wxPyBeginAllowThreads();
50434 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50435 wxPyEndAllowThreads(__tstate);
50436 if (PyErr_Occurred()) SWIG_fail;
50437 }
50438 resultobj = SWIG_Py_Void();
50439 return resultobj;
50440 fail:
50441 return NULL;
50442 }
50443
50444
50445 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50446 PyObject *resultobj = 0;
50447 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50448 wxWindow *arg2 = (wxWindow *) 0 ;
50449 wxGBPosition result;
50450 void *argp1 = 0 ;
50451 int res1 = 0 ;
50452 void *argp2 = 0 ;
50453 int res2 = 0 ;
50454
50455 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50457 if (!SWIG_IsOK(res1)) {
50458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50459 }
50460 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50461 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50462 if (!SWIG_IsOK(res2)) {
50463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50464 }
50465 arg2 = reinterpret_cast< wxWindow * >(argp2);
50466 {
50467 PyThreadState* __tstate = wxPyBeginAllowThreads();
50468 result = (arg1)->GetItemPosition(arg2);
50469 wxPyEndAllowThreads(__tstate);
50470 if (PyErr_Occurred()) SWIG_fail;
50471 }
50472 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50473 return resultobj;
50474 fail:
50475 return NULL;
50476 }
50477
50478
50479 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50480 PyObject *resultobj = 0;
50481 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50482 wxSizer *arg2 = (wxSizer *) 0 ;
50483 wxGBPosition result;
50484 void *argp1 = 0 ;
50485 int res1 = 0 ;
50486 void *argp2 = 0 ;
50487 int res2 = 0 ;
50488
50489 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50491 if (!SWIG_IsOK(res1)) {
50492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50493 }
50494 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50496 if (!SWIG_IsOK(res2)) {
50497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50498 }
50499 arg2 = reinterpret_cast< wxSizer * >(argp2);
50500 {
50501 PyThreadState* __tstate = wxPyBeginAllowThreads();
50502 result = (arg1)->GetItemPosition(arg2);
50503 wxPyEndAllowThreads(__tstate);
50504 if (PyErr_Occurred()) SWIG_fail;
50505 }
50506 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50507 return resultobj;
50508 fail:
50509 return NULL;
50510 }
50511
50512
50513 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50514 PyObject *resultobj = 0;
50515 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50516 size_t arg2 ;
50517 wxGBPosition result;
50518 void *argp1 = 0 ;
50519 int res1 = 0 ;
50520 size_t val2 ;
50521 int ecode2 = 0 ;
50522
50523 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50525 if (!SWIG_IsOK(res1)) {
50526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50527 }
50528 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50529 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50530 if (!SWIG_IsOK(ecode2)) {
50531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50532 }
50533 arg2 = static_cast< size_t >(val2);
50534 {
50535 PyThreadState* __tstate = wxPyBeginAllowThreads();
50536 result = (arg1)->GetItemPosition(arg2);
50537 wxPyEndAllowThreads(__tstate);
50538 if (PyErr_Occurred()) SWIG_fail;
50539 }
50540 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50541 return resultobj;
50542 fail:
50543 return NULL;
50544 }
50545
50546
50547 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50548 int argc;
50549 PyObject *argv[3];
50550
50551 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50552 --argc;
50553 if (argc == 2) {
50554 int _v = 0;
50555 {
50556 void *vptr = 0;
50557 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50558 _v = SWIG_CheckState(res);
50559 }
50560 if (!_v) goto check_1;
50561 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50562 }
50563 check_1:
50564
50565 if (argc == 2) {
50566 int _v = 0;
50567 {
50568 void *vptr = 0;
50569 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50570 _v = SWIG_CheckState(res);
50571 }
50572 if (!_v) goto check_2;
50573 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50574 }
50575 check_2:
50576
50577 if (argc == 2) {
50578 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50579 }
50580
50581 fail:
50582 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50583 return NULL;
50584 }
50585
50586
50587 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50588 PyObject *resultobj = 0;
50589 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50590 wxWindow *arg2 = (wxWindow *) 0 ;
50591 wxGBPosition *arg3 = 0 ;
50592 bool result;
50593 void *argp1 = 0 ;
50594 int res1 = 0 ;
50595 void *argp2 = 0 ;
50596 int res2 = 0 ;
50597 wxGBPosition temp3 ;
50598
50599 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50601 if (!SWIG_IsOK(res1)) {
50602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50603 }
50604 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50605 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50606 if (!SWIG_IsOK(res2)) {
50607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50608 }
50609 arg2 = reinterpret_cast< wxWindow * >(argp2);
50610 {
50611 arg3 = &temp3;
50612 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50613 }
50614 {
50615 PyThreadState* __tstate = wxPyBeginAllowThreads();
50616 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50617 wxPyEndAllowThreads(__tstate);
50618 if (PyErr_Occurred()) SWIG_fail;
50619 }
50620 {
50621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50622 }
50623 return resultobj;
50624 fail:
50625 return NULL;
50626 }
50627
50628
50629 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50630 PyObject *resultobj = 0;
50631 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50632 wxSizer *arg2 = (wxSizer *) 0 ;
50633 wxGBPosition *arg3 = 0 ;
50634 bool result;
50635 void *argp1 = 0 ;
50636 int res1 = 0 ;
50637 void *argp2 = 0 ;
50638 int res2 = 0 ;
50639 wxGBPosition temp3 ;
50640
50641 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50643 if (!SWIG_IsOK(res1)) {
50644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50645 }
50646 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50647 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50648 if (!SWIG_IsOK(res2)) {
50649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50650 }
50651 arg2 = reinterpret_cast< wxSizer * >(argp2);
50652 {
50653 arg3 = &temp3;
50654 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50655 }
50656 {
50657 PyThreadState* __tstate = wxPyBeginAllowThreads();
50658 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50659 wxPyEndAllowThreads(__tstate);
50660 if (PyErr_Occurred()) SWIG_fail;
50661 }
50662 {
50663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50664 }
50665 return resultobj;
50666 fail:
50667 return NULL;
50668 }
50669
50670
50671 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50672 PyObject *resultobj = 0;
50673 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50674 size_t arg2 ;
50675 wxGBPosition *arg3 = 0 ;
50676 bool result;
50677 void *argp1 = 0 ;
50678 int res1 = 0 ;
50679 size_t val2 ;
50680 int ecode2 = 0 ;
50681 wxGBPosition temp3 ;
50682
50683 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50685 if (!SWIG_IsOK(res1)) {
50686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50687 }
50688 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50689 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50690 if (!SWIG_IsOK(ecode2)) {
50691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50692 }
50693 arg2 = static_cast< size_t >(val2);
50694 {
50695 arg3 = &temp3;
50696 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50697 }
50698 {
50699 PyThreadState* __tstate = wxPyBeginAllowThreads();
50700 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50701 wxPyEndAllowThreads(__tstate);
50702 if (PyErr_Occurred()) SWIG_fail;
50703 }
50704 {
50705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50706 }
50707 return resultobj;
50708 fail:
50709 return NULL;
50710 }
50711
50712
50713 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50714 int argc;
50715 PyObject *argv[4];
50716
50717 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50718 --argc;
50719 if (argc == 3) {
50720 int _v = 0;
50721 {
50722 void *vptr = 0;
50723 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50724 _v = SWIG_CheckState(res);
50725 }
50726 if (!_v) goto check_1;
50727 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50728 }
50729 check_1:
50730
50731 if (argc == 3) {
50732 int _v = 0;
50733 {
50734 void *vptr = 0;
50735 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50736 _v = SWIG_CheckState(res);
50737 }
50738 if (!_v) goto check_2;
50739 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50740 }
50741 check_2:
50742
50743 if (argc == 3) {
50744 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50745 }
50746
50747 fail:
50748 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50749 return NULL;
50750 }
50751
50752
50753 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50754 PyObject *resultobj = 0;
50755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50756 wxWindow *arg2 = (wxWindow *) 0 ;
50757 wxGBSpan result;
50758 void *argp1 = 0 ;
50759 int res1 = 0 ;
50760 void *argp2 = 0 ;
50761 int res2 = 0 ;
50762
50763 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50765 if (!SWIG_IsOK(res1)) {
50766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50767 }
50768 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50769 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50770 if (!SWIG_IsOK(res2)) {
50771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50772 }
50773 arg2 = reinterpret_cast< wxWindow * >(argp2);
50774 {
50775 PyThreadState* __tstate = wxPyBeginAllowThreads();
50776 result = (arg1)->GetItemSpan(arg2);
50777 wxPyEndAllowThreads(__tstate);
50778 if (PyErr_Occurred()) SWIG_fail;
50779 }
50780 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50781 return resultobj;
50782 fail:
50783 return NULL;
50784 }
50785
50786
50787 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50788 PyObject *resultobj = 0;
50789 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50790 wxSizer *arg2 = (wxSizer *) 0 ;
50791 wxGBSpan result;
50792 void *argp1 = 0 ;
50793 int res1 = 0 ;
50794 void *argp2 = 0 ;
50795 int res2 = 0 ;
50796
50797 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50799 if (!SWIG_IsOK(res1)) {
50800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50801 }
50802 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50803 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50804 if (!SWIG_IsOK(res2)) {
50805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50806 }
50807 arg2 = reinterpret_cast< wxSizer * >(argp2);
50808 {
50809 PyThreadState* __tstate = wxPyBeginAllowThreads();
50810 result = (arg1)->GetItemSpan(arg2);
50811 wxPyEndAllowThreads(__tstate);
50812 if (PyErr_Occurred()) SWIG_fail;
50813 }
50814 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50815 return resultobj;
50816 fail:
50817 return NULL;
50818 }
50819
50820
50821 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50822 PyObject *resultobj = 0;
50823 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50824 size_t arg2 ;
50825 wxGBSpan result;
50826 void *argp1 = 0 ;
50827 int res1 = 0 ;
50828 size_t val2 ;
50829 int ecode2 = 0 ;
50830
50831 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50833 if (!SWIG_IsOK(res1)) {
50834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50835 }
50836 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50837 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50838 if (!SWIG_IsOK(ecode2)) {
50839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50840 }
50841 arg2 = static_cast< size_t >(val2);
50842 {
50843 PyThreadState* __tstate = wxPyBeginAllowThreads();
50844 result = (arg1)->GetItemSpan(arg2);
50845 wxPyEndAllowThreads(__tstate);
50846 if (PyErr_Occurred()) SWIG_fail;
50847 }
50848 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50849 return resultobj;
50850 fail:
50851 return NULL;
50852 }
50853
50854
50855 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50856 int argc;
50857 PyObject *argv[3];
50858
50859 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50860 --argc;
50861 if (argc == 2) {
50862 int _v = 0;
50863 {
50864 void *vptr = 0;
50865 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50866 _v = SWIG_CheckState(res);
50867 }
50868 if (!_v) goto check_1;
50869 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50870 }
50871 check_1:
50872
50873 if (argc == 2) {
50874 int _v = 0;
50875 {
50876 void *vptr = 0;
50877 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50878 _v = SWIG_CheckState(res);
50879 }
50880 if (!_v) goto check_2;
50881 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50882 }
50883 check_2:
50884
50885 if (argc == 2) {
50886 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50887 }
50888
50889 fail:
50890 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50891 return NULL;
50892 }
50893
50894
50895 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50896 PyObject *resultobj = 0;
50897 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50898 wxWindow *arg2 = (wxWindow *) 0 ;
50899 wxGBSpan *arg3 = 0 ;
50900 bool result;
50901 void *argp1 = 0 ;
50902 int res1 = 0 ;
50903 void *argp2 = 0 ;
50904 int res2 = 0 ;
50905 wxGBSpan temp3 ;
50906
50907 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50909 if (!SWIG_IsOK(res1)) {
50910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50911 }
50912 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50913 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50914 if (!SWIG_IsOK(res2)) {
50915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50916 }
50917 arg2 = reinterpret_cast< wxWindow * >(argp2);
50918 {
50919 arg3 = &temp3;
50920 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50921 }
50922 {
50923 PyThreadState* __tstate = wxPyBeginAllowThreads();
50924 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50925 wxPyEndAllowThreads(__tstate);
50926 if (PyErr_Occurred()) SWIG_fail;
50927 }
50928 {
50929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50930 }
50931 return resultobj;
50932 fail:
50933 return NULL;
50934 }
50935
50936
50937 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50938 PyObject *resultobj = 0;
50939 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50940 wxSizer *arg2 = (wxSizer *) 0 ;
50941 wxGBSpan *arg3 = 0 ;
50942 bool result;
50943 void *argp1 = 0 ;
50944 int res1 = 0 ;
50945 void *argp2 = 0 ;
50946 int res2 = 0 ;
50947 wxGBSpan temp3 ;
50948
50949 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50951 if (!SWIG_IsOK(res1)) {
50952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50953 }
50954 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50955 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50956 if (!SWIG_IsOK(res2)) {
50957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50958 }
50959 arg2 = reinterpret_cast< wxSizer * >(argp2);
50960 {
50961 arg3 = &temp3;
50962 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50963 }
50964 {
50965 PyThreadState* __tstate = wxPyBeginAllowThreads();
50966 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50967 wxPyEndAllowThreads(__tstate);
50968 if (PyErr_Occurred()) SWIG_fail;
50969 }
50970 {
50971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50972 }
50973 return resultobj;
50974 fail:
50975 return NULL;
50976 }
50977
50978
50979 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50980 PyObject *resultobj = 0;
50981 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50982 size_t arg2 ;
50983 wxGBSpan *arg3 = 0 ;
50984 bool result;
50985 void *argp1 = 0 ;
50986 int res1 = 0 ;
50987 size_t val2 ;
50988 int ecode2 = 0 ;
50989 wxGBSpan temp3 ;
50990
50991 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50993 if (!SWIG_IsOK(res1)) {
50994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50995 }
50996 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50997 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50998 if (!SWIG_IsOK(ecode2)) {
50999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51000 }
51001 arg2 = static_cast< size_t >(val2);
51002 {
51003 arg3 = &temp3;
51004 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51005 }
51006 {
51007 PyThreadState* __tstate = wxPyBeginAllowThreads();
51008 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51009 wxPyEndAllowThreads(__tstate);
51010 if (PyErr_Occurred()) SWIG_fail;
51011 }
51012 {
51013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51014 }
51015 return resultobj;
51016 fail:
51017 return NULL;
51018 }
51019
51020
51021 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51022 int argc;
51023 PyObject *argv[4];
51024
51025 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51026 --argc;
51027 if (argc == 3) {
51028 int _v = 0;
51029 {
51030 void *vptr = 0;
51031 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51032 _v = SWIG_CheckState(res);
51033 }
51034 if (!_v) goto check_1;
51035 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51036 }
51037 check_1:
51038
51039 if (argc == 3) {
51040 int _v = 0;
51041 {
51042 void *vptr = 0;
51043 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51044 _v = SWIG_CheckState(res);
51045 }
51046 if (!_v) goto check_2;
51047 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51048 }
51049 check_2:
51050
51051 if (argc == 3) {
51052 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51053 }
51054
51055 fail:
51056 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51057 return NULL;
51058 }
51059
51060
51061 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51062 PyObject *resultobj = 0;
51063 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51064 wxWindow *arg2 = (wxWindow *) 0 ;
51065 wxGBSizerItem *result = 0 ;
51066 void *argp1 = 0 ;
51067 int res1 = 0 ;
51068 void *argp2 = 0 ;
51069 int res2 = 0 ;
51070
51071 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51073 if (!SWIG_IsOK(res1)) {
51074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51075 }
51076 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51077 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51078 if (!SWIG_IsOK(res2)) {
51079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51080 }
51081 arg2 = reinterpret_cast< wxWindow * >(argp2);
51082 {
51083 PyThreadState* __tstate = wxPyBeginAllowThreads();
51084 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51085 wxPyEndAllowThreads(__tstate);
51086 if (PyErr_Occurred()) SWIG_fail;
51087 }
51088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51096 PyObject *resultobj = 0;
51097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51098 wxSizer *arg2 = (wxSizer *) 0 ;
51099 wxGBSizerItem *result = 0 ;
51100 void *argp1 = 0 ;
51101 int res1 = 0 ;
51102 void *argp2 = 0 ;
51103 int res2 = 0 ;
51104
51105 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51107 if (!SWIG_IsOK(res1)) {
51108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51109 }
51110 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51111 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51112 if (!SWIG_IsOK(res2)) {
51113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51114 }
51115 arg2 = reinterpret_cast< wxSizer * >(argp2);
51116 {
51117 PyThreadState* __tstate = wxPyBeginAllowThreads();
51118 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51119 wxPyEndAllowThreads(__tstate);
51120 if (PyErr_Occurred()) SWIG_fail;
51121 }
51122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51123 return resultobj;
51124 fail:
51125 return NULL;
51126 }
51127
51128
51129 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51130 int argc;
51131 PyObject *argv[3];
51132
51133 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51134 --argc;
51135 if (argc == 2) {
51136 int _v = 0;
51137 {
51138 void *vptr = 0;
51139 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51140 _v = SWIG_CheckState(res);
51141 }
51142 if (!_v) goto check_1;
51143 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51144 }
51145 check_1:
51146
51147 if (argc == 2) {
51148 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51149 }
51150
51151 fail:
51152 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51153 return NULL;
51154 }
51155
51156
51157 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51158 PyObject *resultobj = 0;
51159 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51160 wxGBPosition *arg2 = 0 ;
51161 wxGBSizerItem *result = 0 ;
51162 void *argp1 = 0 ;
51163 int res1 = 0 ;
51164 wxGBPosition temp2 ;
51165 PyObject * obj0 = 0 ;
51166 PyObject * obj1 = 0 ;
51167 char * kwnames[] = {
51168 (char *) "self",(char *) "pos", NULL
51169 };
51170
51171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51173 if (!SWIG_IsOK(res1)) {
51174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51175 }
51176 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51177 {
51178 arg2 = &temp2;
51179 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51180 }
51181 {
51182 PyThreadState* __tstate = wxPyBeginAllowThreads();
51183 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51184 wxPyEndAllowThreads(__tstate);
51185 if (PyErr_Occurred()) SWIG_fail;
51186 }
51187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51188 return resultobj;
51189 fail:
51190 return NULL;
51191 }
51192
51193
51194 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51195 PyObject *resultobj = 0;
51196 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51197 wxPoint *arg2 = 0 ;
51198 wxGBSizerItem *result = 0 ;
51199 void *argp1 = 0 ;
51200 int res1 = 0 ;
51201 wxPoint temp2 ;
51202 PyObject * obj0 = 0 ;
51203 PyObject * obj1 = 0 ;
51204 char * kwnames[] = {
51205 (char *) "self",(char *) "pt", NULL
51206 };
51207
51208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51210 if (!SWIG_IsOK(res1)) {
51211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51212 }
51213 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51214 {
51215 arg2 = &temp2;
51216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51217 }
51218 {
51219 PyThreadState* __tstate = wxPyBeginAllowThreads();
51220 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51221 wxPyEndAllowThreads(__tstate);
51222 if (PyErr_Occurred()) SWIG_fail;
51223 }
51224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51225 return resultobj;
51226 fail:
51227 return NULL;
51228 }
51229
51230
51231 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51232 PyObject *resultobj = 0;
51233 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51234 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51235 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51236 bool result;
51237 void *argp1 = 0 ;
51238 int res1 = 0 ;
51239 void *argp2 = 0 ;
51240 int res2 = 0 ;
51241 void *argp3 = 0 ;
51242 int res3 = 0 ;
51243 PyObject * obj0 = 0 ;
51244 PyObject * obj1 = 0 ;
51245 PyObject * obj2 = 0 ;
51246 char * kwnames[] = {
51247 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51248 };
51249
51250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51252 if (!SWIG_IsOK(res1)) {
51253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51254 }
51255 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51257 if (!SWIG_IsOK(res2)) {
51258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51259 }
51260 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51261 if (obj2) {
51262 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51263 if (!SWIG_IsOK(res3)) {
51264 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51265 }
51266 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51267 }
51268 {
51269 PyThreadState* __tstate = wxPyBeginAllowThreads();
51270 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51271 wxPyEndAllowThreads(__tstate);
51272 if (PyErr_Occurred()) SWIG_fail;
51273 }
51274 {
51275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51276 }
51277 return resultobj;
51278 fail:
51279 return NULL;
51280 }
51281
51282
51283 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51284 PyObject *resultobj = 0;
51285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51286 wxGBPosition *arg2 = 0 ;
51287 wxGBSpan *arg3 = 0 ;
51288 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51289 bool result;
51290 void *argp1 = 0 ;
51291 int res1 = 0 ;
51292 wxGBPosition temp2 ;
51293 wxGBSpan temp3 ;
51294 void *argp4 = 0 ;
51295 int res4 = 0 ;
51296 PyObject * obj0 = 0 ;
51297 PyObject * obj1 = 0 ;
51298 PyObject * obj2 = 0 ;
51299 PyObject * obj3 = 0 ;
51300 char * kwnames[] = {
51301 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51302 };
51303
51304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51306 if (!SWIG_IsOK(res1)) {
51307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51308 }
51309 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51310 {
51311 arg2 = &temp2;
51312 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51313 }
51314 {
51315 arg3 = &temp3;
51316 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51317 }
51318 if (obj3) {
51319 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51320 if (!SWIG_IsOK(res4)) {
51321 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51322 }
51323 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51324 }
51325 {
51326 PyThreadState* __tstate = wxPyBeginAllowThreads();
51327 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51328 wxPyEndAllowThreads(__tstate);
51329 if (PyErr_Occurred()) SWIG_fail;
51330 }
51331 {
51332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51333 }
51334 return resultobj;
51335 fail:
51336 return NULL;
51337 }
51338
51339
51340 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51341 PyObject *obj;
51342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51343 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51344 return SWIG_Py_Void();
51345 }
51346
51347 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51348 return SWIG_Python_InitShadowInstance(args);
51349 }
51350
51351 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51352 PyObject *resultobj = 0;
51353 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51354 wxRelationship arg2 ;
51355 wxWindow *arg3 = (wxWindow *) 0 ;
51356 wxEdge arg4 ;
51357 int arg5 = (int) 0 ;
51358 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51359 void *argp1 = 0 ;
51360 int res1 = 0 ;
51361 int val2 ;
51362 int ecode2 = 0 ;
51363 void *argp3 = 0 ;
51364 int res3 = 0 ;
51365 int val4 ;
51366 int ecode4 = 0 ;
51367 int val5 ;
51368 int ecode5 = 0 ;
51369 int val6 ;
51370 int ecode6 = 0 ;
51371 PyObject * obj0 = 0 ;
51372 PyObject * obj1 = 0 ;
51373 PyObject * obj2 = 0 ;
51374 PyObject * obj3 = 0 ;
51375 PyObject * obj4 = 0 ;
51376 PyObject * obj5 = 0 ;
51377 char * kwnames[] = {
51378 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51379 };
51380
51381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51383 if (!SWIG_IsOK(res1)) {
51384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51385 }
51386 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51387 ecode2 = SWIG_AsVal_int(obj1, &val2);
51388 if (!SWIG_IsOK(ecode2)) {
51389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51390 }
51391 arg2 = static_cast< wxRelationship >(val2);
51392 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51393 if (!SWIG_IsOK(res3)) {
51394 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51395 }
51396 arg3 = reinterpret_cast< wxWindow * >(argp3);
51397 ecode4 = SWIG_AsVal_int(obj3, &val4);
51398 if (!SWIG_IsOK(ecode4)) {
51399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51400 }
51401 arg4 = static_cast< wxEdge >(val4);
51402 if (obj4) {
51403 ecode5 = SWIG_AsVal_int(obj4, &val5);
51404 if (!SWIG_IsOK(ecode5)) {
51405 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51406 }
51407 arg5 = static_cast< int >(val5);
51408 }
51409 if (obj5) {
51410 ecode6 = SWIG_AsVal_int(obj5, &val6);
51411 if (!SWIG_IsOK(ecode6)) {
51412 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51413 }
51414 arg6 = static_cast< int >(val6);
51415 }
51416 {
51417 PyThreadState* __tstate = wxPyBeginAllowThreads();
51418 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51419 wxPyEndAllowThreads(__tstate);
51420 if (PyErr_Occurred()) SWIG_fail;
51421 }
51422 resultobj = SWIG_Py_Void();
51423 return resultobj;
51424 fail:
51425 return NULL;
51426 }
51427
51428
51429 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51430 PyObject *resultobj = 0;
51431 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51432 wxWindow *arg2 = (wxWindow *) 0 ;
51433 int arg3 = (int) 0 ;
51434 void *argp1 = 0 ;
51435 int res1 = 0 ;
51436 void *argp2 = 0 ;
51437 int res2 = 0 ;
51438 int val3 ;
51439 int ecode3 = 0 ;
51440 PyObject * obj0 = 0 ;
51441 PyObject * obj1 = 0 ;
51442 PyObject * obj2 = 0 ;
51443 char * kwnames[] = {
51444 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51445 };
51446
51447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51449 if (!SWIG_IsOK(res1)) {
51450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51451 }
51452 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51454 if (!SWIG_IsOK(res2)) {
51455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51456 }
51457 arg2 = reinterpret_cast< wxWindow * >(argp2);
51458 if (obj2) {
51459 ecode3 = SWIG_AsVal_int(obj2, &val3);
51460 if (!SWIG_IsOK(ecode3)) {
51461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51462 }
51463 arg3 = static_cast< int >(val3);
51464 }
51465 {
51466 PyThreadState* __tstate = wxPyBeginAllowThreads();
51467 (arg1)->LeftOf(arg2,arg3);
51468 wxPyEndAllowThreads(__tstate);
51469 if (PyErr_Occurred()) SWIG_fail;
51470 }
51471 resultobj = SWIG_Py_Void();
51472 return resultobj;
51473 fail:
51474 return NULL;
51475 }
51476
51477
51478 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51479 PyObject *resultobj = 0;
51480 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51481 wxWindow *arg2 = (wxWindow *) 0 ;
51482 int arg3 = (int) 0 ;
51483 void *argp1 = 0 ;
51484 int res1 = 0 ;
51485 void *argp2 = 0 ;
51486 int res2 = 0 ;
51487 int val3 ;
51488 int ecode3 = 0 ;
51489 PyObject * obj0 = 0 ;
51490 PyObject * obj1 = 0 ;
51491 PyObject * obj2 = 0 ;
51492 char * kwnames[] = {
51493 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51494 };
51495
51496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51498 if (!SWIG_IsOK(res1)) {
51499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51500 }
51501 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51503 if (!SWIG_IsOK(res2)) {
51504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51505 }
51506 arg2 = reinterpret_cast< wxWindow * >(argp2);
51507 if (obj2) {
51508 ecode3 = SWIG_AsVal_int(obj2, &val3);
51509 if (!SWIG_IsOK(ecode3)) {
51510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51511 }
51512 arg3 = static_cast< int >(val3);
51513 }
51514 {
51515 PyThreadState* __tstate = wxPyBeginAllowThreads();
51516 (arg1)->RightOf(arg2,arg3);
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_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51528 PyObject *resultobj = 0;
51529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51530 wxWindow *arg2 = (wxWindow *) 0 ;
51531 int arg3 = (int) 0 ;
51532 void *argp1 = 0 ;
51533 int res1 = 0 ;
51534 void *argp2 = 0 ;
51535 int res2 = 0 ;
51536 int val3 ;
51537 int ecode3 = 0 ;
51538 PyObject * obj0 = 0 ;
51539 PyObject * obj1 = 0 ;
51540 PyObject * obj2 = 0 ;
51541 char * kwnames[] = {
51542 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51543 };
51544
51545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51547 if (!SWIG_IsOK(res1)) {
51548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51549 }
51550 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51552 if (!SWIG_IsOK(res2)) {
51553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51554 }
51555 arg2 = reinterpret_cast< wxWindow * >(argp2);
51556 if (obj2) {
51557 ecode3 = SWIG_AsVal_int(obj2, &val3);
51558 if (!SWIG_IsOK(ecode3)) {
51559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51560 }
51561 arg3 = static_cast< int >(val3);
51562 }
51563 {
51564 PyThreadState* __tstate = wxPyBeginAllowThreads();
51565 (arg1)->Above(arg2,arg3);
51566 wxPyEndAllowThreads(__tstate);
51567 if (PyErr_Occurred()) SWIG_fail;
51568 }
51569 resultobj = SWIG_Py_Void();
51570 return resultobj;
51571 fail:
51572 return NULL;
51573 }
51574
51575
51576 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51577 PyObject *resultobj = 0;
51578 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51579 wxWindow *arg2 = (wxWindow *) 0 ;
51580 int arg3 = (int) 0 ;
51581 void *argp1 = 0 ;
51582 int res1 = 0 ;
51583 void *argp2 = 0 ;
51584 int res2 = 0 ;
51585 int val3 ;
51586 int ecode3 = 0 ;
51587 PyObject * obj0 = 0 ;
51588 PyObject * obj1 = 0 ;
51589 PyObject * obj2 = 0 ;
51590 char * kwnames[] = {
51591 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51592 };
51593
51594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51596 if (!SWIG_IsOK(res1)) {
51597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51598 }
51599 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51601 if (!SWIG_IsOK(res2)) {
51602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51603 }
51604 arg2 = reinterpret_cast< wxWindow * >(argp2);
51605 if (obj2) {
51606 ecode3 = SWIG_AsVal_int(obj2, &val3);
51607 if (!SWIG_IsOK(ecode3)) {
51608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51609 }
51610 arg3 = static_cast< int >(val3);
51611 }
51612 {
51613 PyThreadState* __tstate = wxPyBeginAllowThreads();
51614 (arg1)->Below(arg2,arg3);
51615 wxPyEndAllowThreads(__tstate);
51616 if (PyErr_Occurred()) SWIG_fail;
51617 }
51618 resultobj = SWIG_Py_Void();
51619 return resultobj;
51620 fail:
51621 return NULL;
51622 }
51623
51624
51625 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51626 PyObject *resultobj = 0;
51627 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51628 wxWindow *arg2 = (wxWindow *) 0 ;
51629 wxEdge arg3 ;
51630 int arg4 = (int) 0 ;
51631 void *argp1 = 0 ;
51632 int res1 = 0 ;
51633 void *argp2 = 0 ;
51634 int res2 = 0 ;
51635 int val3 ;
51636 int ecode3 = 0 ;
51637 int val4 ;
51638 int ecode4 = 0 ;
51639 PyObject * obj0 = 0 ;
51640 PyObject * obj1 = 0 ;
51641 PyObject * obj2 = 0 ;
51642 PyObject * obj3 = 0 ;
51643 char * kwnames[] = {
51644 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51645 };
51646
51647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51649 if (!SWIG_IsOK(res1)) {
51650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51651 }
51652 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51654 if (!SWIG_IsOK(res2)) {
51655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51656 }
51657 arg2 = reinterpret_cast< wxWindow * >(argp2);
51658 ecode3 = SWIG_AsVal_int(obj2, &val3);
51659 if (!SWIG_IsOK(ecode3)) {
51660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51661 }
51662 arg3 = static_cast< wxEdge >(val3);
51663 if (obj3) {
51664 ecode4 = SWIG_AsVal_int(obj3, &val4);
51665 if (!SWIG_IsOK(ecode4)) {
51666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51667 }
51668 arg4 = static_cast< int >(val4);
51669 }
51670 {
51671 PyThreadState* __tstate = wxPyBeginAllowThreads();
51672 (arg1)->SameAs(arg2,arg3,arg4);
51673 wxPyEndAllowThreads(__tstate);
51674 if (PyErr_Occurred()) SWIG_fail;
51675 }
51676 resultobj = SWIG_Py_Void();
51677 return resultobj;
51678 fail:
51679 return NULL;
51680 }
51681
51682
51683 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51684 PyObject *resultobj = 0;
51685 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51686 wxWindow *arg2 = (wxWindow *) 0 ;
51687 wxEdge arg3 ;
51688 int arg4 ;
51689 void *argp1 = 0 ;
51690 int res1 = 0 ;
51691 void *argp2 = 0 ;
51692 int res2 = 0 ;
51693 int val3 ;
51694 int ecode3 = 0 ;
51695 int val4 ;
51696 int ecode4 = 0 ;
51697 PyObject * obj0 = 0 ;
51698 PyObject * obj1 = 0 ;
51699 PyObject * obj2 = 0 ;
51700 PyObject * obj3 = 0 ;
51701 char * kwnames[] = {
51702 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51703 };
51704
51705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51707 if (!SWIG_IsOK(res1)) {
51708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51709 }
51710 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51712 if (!SWIG_IsOK(res2)) {
51713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51714 }
51715 arg2 = reinterpret_cast< wxWindow * >(argp2);
51716 ecode3 = SWIG_AsVal_int(obj2, &val3);
51717 if (!SWIG_IsOK(ecode3)) {
51718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51719 }
51720 arg3 = static_cast< wxEdge >(val3);
51721 ecode4 = SWIG_AsVal_int(obj3, &val4);
51722 if (!SWIG_IsOK(ecode4)) {
51723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51724 }
51725 arg4 = static_cast< int >(val4);
51726 {
51727 PyThreadState* __tstate = wxPyBeginAllowThreads();
51728 (arg1)->PercentOf(arg2,arg3,arg4);
51729 wxPyEndAllowThreads(__tstate);
51730 if (PyErr_Occurred()) SWIG_fail;
51731 }
51732 resultobj = SWIG_Py_Void();
51733 return resultobj;
51734 fail:
51735 return NULL;
51736 }
51737
51738
51739 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51740 PyObject *resultobj = 0;
51741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51742 int arg2 ;
51743 void *argp1 = 0 ;
51744 int res1 = 0 ;
51745 int val2 ;
51746 int ecode2 = 0 ;
51747 PyObject * obj0 = 0 ;
51748 PyObject * obj1 = 0 ;
51749 char * kwnames[] = {
51750 (char *) "self",(char *) "val", NULL
51751 };
51752
51753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51755 if (!SWIG_IsOK(res1)) {
51756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51757 }
51758 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51759 ecode2 = SWIG_AsVal_int(obj1, &val2);
51760 if (!SWIG_IsOK(ecode2)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51762 }
51763 arg2 = static_cast< int >(val2);
51764 {
51765 PyThreadState* __tstate = wxPyBeginAllowThreads();
51766 (arg1)->Absolute(arg2);
51767 wxPyEndAllowThreads(__tstate);
51768 if (PyErr_Occurred()) SWIG_fail;
51769 }
51770 resultobj = SWIG_Py_Void();
51771 return resultobj;
51772 fail:
51773 return NULL;
51774 }
51775
51776
51777 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51778 PyObject *resultobj = 0;
51779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51780 void *argp1 = 0 ;
51781 int res1 = 0 ;
51782 PyObject *swig_obj[1] ;
51783
51784 if (!args) SWIG_fail;
51785 swig_obj[0] = args;
51786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51787 if (!SWIG_IsOK(res1)) {
51788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51789 }
51790 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51791 {
51792 PyThreadState* __tstate = wxPyBeginAllowThreads();
51793 (arg1)->Unconstrained();
51794 wxPyEndAllowThreads(__tstate);
51795 if (PyErr_Occurred()) SWIG_fail;
51796 }
51797 resultobj = SWIG_Py_Void();
51798 return resultobj;
51799 fail:
51800 return NULL;
51801 }
51802
51803
51804 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51805 PyObject *resultobj = 0;
51806 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51807 void *argp1 = 0 ;
51808 int res1 = 0 ;
51809 PyObject *swig_obj[1] ;
51810
51811 if (!args) SWIG_fail;
51812 swig_obj[0] = args;
51813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51814 if (!SWIG_IsOK(res1)) {
51815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51816 }
51817 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51818 {
51819 PyThreadState* __tstate = wxPyBeginAllowThreads();
51820 (arg1)->AsIs();
51821 wxPyEndAllowThreads(__tstate);
51822 if (PyErr_Occurred()) SWIG_fail;
51823 }
51824 resultobj = SWIG_Py_Void();
51825 return resultobj;
51826 fail:
51827 return NULL;
51828 }
51829
51830
51831 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51832 PyObject *resultobj = 0;
51833 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51834 wxWindow *result = 0 ;
51835 void *argp1 = 0 ;
51836 int res1 = 0 ;
51837 PyObject *swig_obj[1] ;
51838
51839 if (!args) SWIG_fail;
51840 swig_obj[0] = args;
51841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51842 if (!SWIG_IsOK(res1)) {
51843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51844 }
51845 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51846 {
51847 PyThreadState* __tstate = wxPyBeginAllowThreads();
51848 result = (wxWindow *)(arg1)->GetOtherWindow();
51849 wxPyEndAllowThreads(__tstate);
51850 if (PyErr_Occurred()) SWIG_fail;
51851 }
51852 {
51853 resultobj = wxPyMake_wxObject(result, 0);
51854 }
51855 return resultobj;
51856 fail:
51857 return NULL;
51858 }
51859
51860
51861 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51862 PyObject *resultobj = 0;
51863 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51864 wxEdge result;
51865 void *argp1 = 0 ;
51866 int res1 = 0 ;
51867 PyObject *swig_obj[1] ;
51868
51869 if (!args) SWIG_fail;
51870 swig_obj[0] = args;
51871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51872 if (!SWIG_IsOK(res1)) {
51873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51874 }
51875 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51876 {
51877 PyThreadState* __tstate = wxPyBeginAllowThreads();
51878 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51879 wxPyEndAllowThreads(__tstate);
51880 if (PyErr_Occurred()) SWIG_fail;
51881 }
51882 resultobj = SWIG_From_int(static_cast< int >(result));
51883 return resultobj;
51884 fail:
51885 return NULL;
51886 }
51887
51888
51889 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51890 PyObject *resultobj = 0;
51891 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51892 wxEdge arg2 ;
51893 void *argp1 = 0 ;
51894 int res1 = 0 ;
51895 int val2 ;
51896 int ecode2 = 0 ;
51897 PyObject * obj0 = 0 ;
51898 PyObject * obj1 = 0 ;
51899 char * kwnames[] = {
51900 (char *) "self",(char *) "which", NULL
51901 };
51902
51903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51905 if (!SWIG_IsOK(res1)) {
51906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51907 }
51908 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51909 ecode2 = SWIG_AsVal_int(obj1, &val2);
51910 if (!SWIG_IsOK(ecode2)) {
51911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51912 }
51913 arg2 = static_cast< wxEdge >(val2);
51914 {
51915 PyThreadState* __tstate = wxPyBeginAllowThreads();
51916 (arg1)->SetEdge(arg2);
51917 wxPyEndAllowThreads(__tstate);
51918 if (PyErr_Occurred()) SWIG_fail;
51919 }
51920 resultobj = SWIG_Py_Void();
51921 return resultobj;
51922 fail:
51923 return NULL;
51924 }
51925
51926
51927 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51928 PyObject *resultobj = 0;
51929 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51930 int arg2 ;
51931 void *argp1 = 0 ;
51932 int res1 = 0 ;
51933 int val2 ;
51934 int ecode2 = 0 ;
51935 PyObject * obj0 = 0 ;
51936 PyObject * obj1 = 0 ;
51937 char * kwnames[] = {
51938 (char *) "self",(char *) "v", NULL
51939 };
51940
51941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51943 if (!SWIG_IsOK(res1)) {
51944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51945 }
51946 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51947 ecode2 = SWIG_AsVal_int(obj1, &val2);
51948 if (!SWIG_IsOK(ecode2)) {
51949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51950 }
51951 arg2 = static_cast< int >(val2);
51952 {
51953 PyThreadState* __tstate = wxPyBeginAllowThreads();
51954 (arg1)->SetValue(arg2);
51955 wxPyEndAllowThreads(__tstate);
51956 if (PyErr_Occurred()) SWIG_fail;
51957 }
51958 resultobj = SWIG_Py_Void();
51959 return resultobj;
51960 fail:
51961 return NULL;
51962 }
51963
51964
51965 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51966 PyObject *resultobj = 0;
51967 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51968 int result;
51969 void *argp1 = 0 ;
51970 int res1 = 0 ;
51971 PyObject *swig_obj[1] ;
51972
51973 if (!args) SWIG_fail;
51974 swig_obj[0] = args;
51975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51976 if (!SWIG_IsOK(res1)) {
51977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51978 }
51979 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51980 {
51981 PyThreadState* __tstate = wxPyBeginAllowThreads();
51982 result = (int)(arg1)->GetMargin();
51983 wxPyEndAllowThreads(__tstate);
51984 if (PyErr_Occurred()) SWIG_fail;
51985 }
51986 resultobj = SWIG_From_int(static_cast< int >(result));
51987 return resultobj;
51988 fail:
51989 return NULL;
51990 }
51991
51992
51993 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51994 PyObject *resultobj = 0;
51995 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51996 int arg2 ;
51997 void *argp1 = 0 ;
51998 int res1 = 0 ;
51999 int val2 ;
52000 int ecode2 = 0 ;
52001 PyObject * obj0 = 0 ;
52002 PyObject * obj1 = 0 ;
52003 char * kwnames[] = {
52004 (char *) "self",(char *) "m", NULL
52005 };
52006
52007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52009 if (!SWIG_IsOK(res1)) {
52010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52011 }
52012 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52013 ecode2 = SWIG_AsVal_int(obj1, &val2);
52014 if (!SWIG_IsOK(ecode2)) {
52015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52016 }
52017 arg2 = static_cast< int >(val2);
52018 {
52019 PyThreadState* __tstate = wxPyBeginAllowThreads();
52020 (arg1)->SetMargin(arg2);
52021 wxPyEndAllowThreads(__tstate);
52022 if (PyErr_Occurred()) SWIG_fail;
52023 }
52024 resultobj = SWIG_Py_Void();
52025 return resultobj;
52026 fail:
52027 return NULL;
52028 }
52029
52030
52031 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52032 PyObject *resultobj = 0;
52033 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52034 int result;
52035 void *argp1 = 0 ;
52036 int res1 = 0 ;
52037 PyObject *swig_obj[1] ;
52038
52039 if (!args) SWIG_fail;
52040 swig_obj[0] = args;
52041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52042 if (!SWIG_IsOK(res1)) {
52043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52044 }
52045 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52046 {
52047 PyThreadState* __tstate = wxPyBeginAllowThreads();
52048 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52049 wxPyEndAllowThreads(__tstate);
52050 if (PyErr_Occurred()) SWIG_fail;
52051 }
52052 resultobj = SWIG_From_int(static_cast< int >(result));
52053 return resultobj;
52054 fail:
52055 return NULL;
52056 }
52057
52058
52059 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52060 PyObject *resultobj = 0;
52061 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52062 int result;
52063 void *argp1 = 0 ;
52064 int res1 = 0 ;
52065 PyObject *swig_obj[1] ;
52066
52067 if (!args) SWIG_fail;
52068 swig_obj[0] = args;
52069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52070 if (!SWIG_IsOK(res1)) {
52071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52072 }
52073 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52074 {
52075 PyThreadState* __tstate = wxPyBeginAllowThreads();
52076 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52077 wxPyEndAllowThreads(__tstate);
52078 if (PyErr_Occurred()) SWIG_fail;
52079 }
52080 resultobj = SWIG_From_int(static_cast< int >(result));
52081 return resultobj;
52082 fail:
52083 return NULL;
52084 }
52085
52086
52087 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52088 PyObject *resultobj = 0;
52089 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52090 int result;
52091 void *argp1 = 0 ;
52092 int res1 = 0 ;
52093 PyObject *swig_obj[1] ;
52094
52095 if (!args) SWIG_fail;
52096 swig_obj[0] = args;
52097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52098 if (!SWIG_IsOK(res1)) {
52099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52100 }
52101 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52102 {
52103 PyThreadState* __tstate = wxPyBeginAllowThreads();
52104 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52105 wxPyEndAllowThreads(__tstate);
52106 if (PyErr_Occurred()) SWIG_fail;
52107 }
52108 resultobj = SWIG_From_int(static_cast< int >(result));
52109 return resultobj;
52110 fail:
52111 return NULL;
52112 }
52113
52114
52115 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52116 PyObject *resultobj = 0;
52117 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52118 bool result;
52119 void *argp1 = 0 ;
52120 int res1 = 0 ;
52121 PyObject *swig_obj[1] ;
52122
52123 if (!args) SWIG_fail;
52124 swig_obj[0] = args;
52125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52126 if (!SWIG_IsOK(res1)) {
52127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52128 }
52129 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52130 {
52131 PyThreadState* __tstate = wxPyBeginAllowThreads();
52132 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52133 wxPyEndAllowThreads(__tstate);
52134 if (PyErr_Occurred()) SWIG_fail;
52135 }
52136 {
52137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52138 }
52139 return resultobj;
52140 fail:
52141 return NULL;
52142 }
52143
52144
52145 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52146 PyObject *resultobj = 0;
52147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52148 bool arg2 ;
52149 void *argp1 = 0 ;
52150 int res1 = 0 ;
52151 bool val2 ;
52152 int ecode2 = 0 ;
52153 PyObject * obj0 = 0 ;
52154 PyObject * obj1 = 0 ;
52155 char * kwnames[] = {
52156 (char *) "self",(char *) "d", NULL
52157 };
52158
52159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52161 if (!SWIG_IsOK(res1)) {
52162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52163 }
52164 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52166 if (!SWIG_IsOK(ecode2)) {
52167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52168 }
52169 arg2 = static_cast< bool >(val2);
52170 {
52171 PyThreadState* __tstate = wxPyBeginAllowThreads();
52172 (arg1)->SetDone(arg2);
52173 wxPyEndAllowThreads(__tstate);
52174 if (PyErr_Occurred()) SWIG_fail;
52175 }
52176 resultobj = SWIG_Py_Void();
52177 return resultobj;
52178 fail:
52179 return NULL;
52180 }
52181
52182
52183 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52184 PyObject *resultobj = 0;
52185 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52186 wxRelationship result;
52187 void *argp1 = 0 ;
52188 int res1 = 0 ;
52189 PyObject *swig_obj[1] ;
52190
52191 if (!args) SWIG_fail;
52192 swig_obj[0] = args;
52193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52194 if (!SWIG_IsOK(res1)) {
52195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52196 }
52197 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52198 {
52199 PyThreadState* __tstate = wxPyBeginAllowThreads();
52200 result = (wxRelationship)(arg1)->GetRelationship();
52201 wxPyEndAllowThreads(__tstate);
52202 if (PyErr_Occurred()) SWIG_fail;
52203 }
52204 resultobj = SWIG_From_int(static_cast< int >(result));
52205 return resultobj;
52206 fail:
52207 return NULL;
52208 }
52209
52210
52211 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52212 PyObject *resultobj = 0;
52213 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52214 wxRelationship arg2 ;
52215 void *argp1 = 0 ;
52216 int res1 = 0 ;
52217 int val2 ;
52218 int ecode2 = 0 ;
52219 PyObject * obj0 = 0 ;
52220 PyObject * obj1 = 0 ;
52221 char * kwnames[] = {
52222 (char *) "self",(char *) "r", NULL
52223 };
52224
52225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52227 if (!SWIG_IsOK(res1)) {
52228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52229 }
52230 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52231 ecode2 = SWIG_AsVal_int(obj1, &val2);
52232 if (!SWIG_IsOK(ecode2)) {
52233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52234 }
52235 arg2 = static_cast< wxRelationship >(val2);
52236 {
52237 PyThreadState* __tstate = wxPyBeginAllowThreads();
52238 (arg1)->SetRelationship(arg2);
52239 wxPyEndAllowThreads(__tstate);
52240 if (PyErr_Occurred()) SWIG_fail;
52241 }
52242 resultobj = SWIG_Py_Void();
52243 return resultobj;
52244 fail:
52245 return NULL;
52246 }
52247
52248
52249 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52250 PyObject *resultobj = 0;
52251 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52252 wxWindow *arg2 = (wxWindow *) 0 ;
52253 bool result;
52254 void *argp1 = 0 ;
52255 int res1 = 0 ;
52256 void *argp2 = 0 ;
52257 int res2 = 0 ;
52258 PyObject * obj0 = 0 ;
52259 PyObject * obj1 = 0 ;
52260 char * kwnames[] = {
52261 (char *) "self",(char *) "otherW", NULL
52262 };
52263
52264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52266 if (!SWIG_IsOK(res1)) {
52267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52268 }
52269 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52271 if (!SWIG_IsOK(res2)) {
52272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52273 }
52274 arg2 = reinterpret_cast< wxWindow * >(argp2);
52275 {
52276 PyThreadState* __tstate = wxPyBeginAllowThreads();
52277 result = (bool)(arg1)->ResetIfWin(arg2);
52278 wxPyEndAllowThreads(__tstate);
52279 if (PyErr_Occurred()) SWIG_fail;
52280 }
52281 {
52282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52283 }
52284 return resultobj;
52285 fail:
52286 return NULL;
52287 }
52288
52289
52290 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52291 PyObject *resultobj = 0;
52292 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52293 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52294 wxWindow *arg3 = (wxWindow *) 0 ;
52295 bool result;
52296 void *argp1 = 0 ;
52297 int res1 = 0 ;
52298 void *argp2 = 0 ;
52299 int res2 = 0 ;
52300 void *argp3 = 0 ;
52301 int res3 = 0 ;
52302 PyObject * obj0 = 0 ;
52303 PyObject * obj1 = 0 ;
52304 PyObject * obj2 = 0 ;
52305 char * kwnames[] = {
52306 (char *) "self",(char *) "constraints",(char *) "win", NULL
52307 };
52308
52309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52311 if (!SWIG_IsOK(res1)) {
52312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52313 }
52314 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52316 if (!SWIG_IsOK(res2)) {
52317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52318 }
52319 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52320 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52321 if (!SWIG_IsOK(res3)) {
52322 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52323 }
52324 arg3 = reinterpret_cast< wxWindow * >(argp3);
52325 {
52326 PyThreadState* __tstate = wxPyBeginAllowThreads();
52327 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52328 wxPyEndAllowThreads(__tstate);
52329 if (PyErr_Occurred()) SWIG_fail;
52330 }
52331 {
52332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52333 }
52334 return resultobj;
52335 fail:
52336 return NULL;
52337 }
52338
52339
52340 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52341 PyObject *resultobj = 0;
52342 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52343 wxEdge arg2 ;
52344 wxWindow *arg3 = (wxWindow *) 0 ;
52345 wxWindow *arg4 = (wxWindow *) 0 ;
52346 int result;
52347 void *argp1 = 0 ;
52348 int res1 = 0 ;
52349 int val2 ;
52350 int ecode2 = 0 ;
52351 void *argp3 = 0 ;
52352 int res3 = 0 ;
52353 void *argp4 = 0 ;
52354 int res4 = 0 ;
52355 PyObject * obj0 = 0 ;
52356 PyObject * obj1 = 0 ;
52357 PyObject * obj2 = 0 ;
52358 PyObject * obj3 = 0 ;
52359 char * kwnames[] = {
52360 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52361 };
52362
52363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52365 if (!SWIG_IsOK(res1)) {
52366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52367 }
52368 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52369 ecode2 = SWIG_AsVal_int(obj1, &val2);
52370 if (!SWIG_IsOK(ecode2)) {
52371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52372 }
52373 arg2 = static_cast< wxEdge >(val2);
52374 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52375 if (!SWIG_IsOK(res3)) {
52376 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52377 }
52378 arg3 = reinterpret_cast< wxWindow * >(argp3);
52379 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52380 if (!SWIG_IsOK(res4)) {
52381 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52382 }
52383 arg4 = reinterpret_cast< wxWindow * >(argp4);
52384 {
52385 PyThreadState* __tstate = wxPyBeginAllowThreads();
52386 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52387 wxPyEndAllowThreads(__tstate);
52388 if (PyErr_Occurred()) SWIG_fail;
52389 }
52390 resultobj = SWIG_From_int(static_cast< int >(result));
52391 return resultobj;
52392 fail:
52393 return NULL;
52394 }
52395
52396
52397 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52398 PyObject *obj;
52399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52400 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52401 return SWIG_Py_Void();
52402 }
52403
52404 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52405 PyObject *resultobj = 0;
52406 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52407 wxIndividualLayoutConstraint *result = 0 ;
52408 void *argp1 = 0 ;
52409 int res1 = 0 ;
52410 PyObject *swig_obj[1] ;
52411
52412 if (!args) SWIG_fail;
52413 swig_obj[0] = args;
52414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52415 if (!SWIG_IsOK(res1)) {
52416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52417 }
52418 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52419 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52421 return resultobj;
52422 fail:
52423 return NULL;
52424 }
52425
52426
52427 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52428 PyObject *resultobj = 0;
52429 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52430 wxIndividualLayoutConstraint *result = 0 ;
52431 void *argp1 = 0 ;
52432 int res1 = 0 ;
52433 PyObject *swig_obj[1] ;
52434
52435 if (!args) SWIG_fail;
52436 swig_obj[0] = args;
52437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52438 if (!SWIG_IsOK(res1)) {
52439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52440 }
52441 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52442 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52444 return resultobj;
52445 fail:
52446 return NULL;
52447 }
52448
52449
52450 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52451 PyObject *resultobj = 0;
52452 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52453 wxIndividualLayoutConstraint *result = 0 ;
52454 void *argp1 = 0 ;
52455 int res1 = 0 ;
52456 PyObject *swig_obj[1] ;
52457
52458 if (!args) SWIG_fail;
52459 swig_obj[0] = args;
52460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52461 if (!SWIG_IsOK(res1)) {
52462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52463 }
52464 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52465 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52467 return resultobj;
52468 fail:
52469 return NULL;
52470 }
52471
52472
52473 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52474 PyObject *resultobj = 0;
52475 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52476 wxIndividualLayoutConstraint *result = 0 ;
52477 void *argp1 = 0 ;
52478 int res1 = 0 ;
52479 PyObject *swig_obj[1] ;
52480
52481 if (!args) SWIG_fail;
52482 swig_obj[0] = args;
52483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52484 if (!SWIG_IsOK(res1)) {
52485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52486 }
52487 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52488 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52490 return resultobj;
52491 fail:
52492 return NULL;
52493 }
52494
52495
52496 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52497 PyObject *resultobj = 0;
52498 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52499 wxIndividualLayoutConstraint *result = 0 ;
52500 void *argp1 = 0 ;
52501 int res1 = 0 ;
52502 PyObject *swig_obj[1] ;
52503
52504 if (!args) SWIG_fail;
52505 swig_obj[0] = args;
52506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52507 if (!SWIG_IsOK(res1)) {
52508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52509 }
52510 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52511 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52513 return resultobj;
52514 fail:
52515 return NULL;
52516 }
52517
52518
52519 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52520 PyObject *resultobj = 0;
52521 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52522 wxIndividualLayoutConstraint *result = 0 ;
52523 void *argp1 = 0 ;
52524 int res1 = 0 ;
52525 PyObject *swig_obj[1] ;
52526
52527 if (!args) SWIG_fail;
52528 swig_obj[0] = args;
52529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52530 if (!SWIG_IsOK(res1)) {
52531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52532 }
52533 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52534 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52536 return resultobj;
52537 fail:
52538 return NULL;
52539 }
52540
52541
52542 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52543 PyObject *resultobj = 0;
52544 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52545 wxIndividualLayoutConstraint *result = 0 ;
52546 void *argp1 = 0 ;
52547 int res1 = 0 ;
52548 PyObject *swig_obj[1] ;
52549
52550 if (!args) SWIG_fail;
52551 swig_obj[0] = args;
52552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52555 }
52556 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52557 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52559 return resultobj;
52560 fail:
52561 return NULL;
52562 }
52563
52564
52565 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52566 PyObject *resultobj = 0;
52567 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52568 wxIndividualLayoutConstraint *result = 0 ;
52569 void *argp1 = 0 ;
52570 int res1 = 0 ;
52571 PyObject *swig_obj[1] ;
52572
52573 if (!args) SWIG_fail;
52574 swig_obj[0] = args;
52575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52576 if (!SWIG_IsOK(res1)) {
52577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52578 }
52579 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52580 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52582 return resultobj;
52583 fail:
52584 return NULL;
52585 }
52586
52587
52588 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52589 PyObject *resultobj = 0;
52590 wxLayoutConstraints *result = 0 ;
52591
52592 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52593 {
52594 PyThreadState* __tstate = wxPyBeginAllowThreads();
52595 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52596 wxPyEndAllowThreads(__tstate);
52597 if (PyErr_Occurred()) SWIG_fail;
52598 }
52599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52600 return resultobj;
52601 fail:
52602 return NULL;
52603 }
52604
52605
52606 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52607 PyObject *resultobj = 0;
52608 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52609 void *argp1 = 0 ;
52610 int res1 = 0 ;
52611 PyObject *swig_obj[1] ;
52612
52613 if (!args) SWIG_fail;
52614 swig_obj[0] = args;
52615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52616 if (!SWIG_IsOK(res1)) {
52617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52618 }
52619 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52620 {
52621 PyThreadState* __tstate = wxPyBeginAllowThreads();
52622 delete arg1;
52623
52624 wxPyEndAllowThreads(__tstate);
52625 if (PyErr_Occurred()) SWIG_fail;
52626 }
52627 resultobj = SWIG_Py_Void();
52628 return resultobj;
52629 fail:
52630 return NULL;
52631 }
52632
52633
52634 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52635 PyObject *resultobj = 0;
52636 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52637 wxWindow *arg2 = (wxWindow *) 0 ;
52638 int *arg3 = (int *) 0 ;
52639 bool result;
52640 void *argp1 = 0 ;
52641 int res1 = 0 ;
52642 void *argp2 = 0 ;
52643 int res2 = 0 ;
52644 int temp3 ;
52645 int res3 = SWIG_TMPOBJ ;
52646 PyObject * obj0 = 0 ;
52647 PyObject * obj1 = 0 ;
52648 char * kwnames[] = {
52649 (char *) "self",(char *) "win", NULL
52650 };
52651
52652 arg3 = &temp3;
52653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52655 if (!SWIG_IsOK(res1)) {
52656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52657 }
52658 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52660 if (!SWIG_IsOK(res2)) {
52661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52662 }
52663 arg2 = reinterpret_cast< wxWindow * >(argp2);
52664 {
52665 PyThreadState* __tstate = wxPyBeginAllowThreads();
52666 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52667 wxPyEndAllowThreads(__tstate);
52668 if (PyErr_Occurred()) SWIG_fail;
52669 }
52670 {
52671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52672 }
52673 if (SWIG_IsTmpObj(res3)) {
52674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52675 } else {
52676 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52678 }
52679 return resultobj;
52680 fail:
52681 return NULL;
52682 }
52683
52684
52685 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52686 PyObject *resultobj = 0;
52687 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52688 bool result;
52689 void *argp1 = 0 ;
52690 int res1 = 0 ;
52691 PyObject *swig_obj[1] ;
52692
52693 if (!args) SWIG_fail;
52694 swig_obj[0] = args;
52695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52696 if (!SWIG_IsOK(res1)) {
52697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52698 }
52699 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52700 {
52701 PyThreadState* __tstate = wxPyBeginAllowThreads();
52702 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52703 wxPyEndAllowThreads(__tstate);
52704 if (PyErr_Occurred()) SWIG_fail;
52705 }
52706 {
52707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52708 }
52709 return resultobj;
52710 fail:
52711 return NULL;
52712 }
52713
52714
52715 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52716 PyObject *obj;
52717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52718 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52719 return SWIG_Py_Void();
52720 }
52721
52722 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52723 return SWIG_Python_InitShadowInstance(args);
52724 }
52725
52726 static PyMethodDef SwigMethods[] = {
52727 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52728 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52729 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52730 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52731 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52732 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52733 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52734 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52735 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52737 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52747 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52748 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52749 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52751 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52752 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52753 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52754 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52755 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52756 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52757 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52759 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52765 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52766 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52767 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52768 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52769 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52770 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52771 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52773 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52781 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52782 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52783 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52788 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52789 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52791 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52793 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52795 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52797 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52799 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52801 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52802 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52804 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52806 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52807 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52808 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52809 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52828 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52829 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52830 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52831 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52832 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52833 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52834 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52835 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52837 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52838 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52839 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52844 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52845 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52846 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52847 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52854 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52861 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52862 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52863 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52864 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52866 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52867 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52868 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52870 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52871 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52872 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52873 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52878 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52879 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52880 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52881 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52882 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52883 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52886 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52887 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52888 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52890 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52891 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52893 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52894 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52895 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52896 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52897 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52898 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52899 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52900 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52901 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52902 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52903 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52908 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52914 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52915 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52916 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52917 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52919 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52922 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52924 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52927 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52928 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52929 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52932 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52933 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52934 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52938 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52939 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52940 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52944 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52949 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52950 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52951 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52952 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52953 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52954 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52955 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52962 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52963 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52965 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52966 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52967 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52973 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52974 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52976 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52977 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52978 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52979 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52980 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52981 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52982 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52983 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52985 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52986 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52987 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52988 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52989 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52990 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52991 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52992 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52994 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53003 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53015 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53016 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53031 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53032 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53033 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53034 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53037 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53039 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53041 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53043 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53045 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53048 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53049 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53050 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53051 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53053 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53070 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53071 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53077 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53078 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53079 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53080 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53081 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53082 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53083 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53084 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53085 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53086 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53087 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53088 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53089 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53090 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53091 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53092 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53093 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53094 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53095 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53096 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53097 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53098 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53099 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53100 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53101 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53102 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53103 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53104 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53105 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53106 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53107 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53109 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53110 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53111 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53113 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53114 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53115 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53116 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53119 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53123 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53127 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53128 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53129 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53130 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53132 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53133 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53135 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53137 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53139 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53141 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53142 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53143 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53145 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53146 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53148 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53149 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53150 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53152 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53153 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53154 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53156 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53158 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53159 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53160 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53162 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53164 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53165 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53167 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53168 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53169 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53171 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53172 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53173 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53174 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53175 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53177 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53178 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53181 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53182 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53184 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53185 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53188 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53189 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53191 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53197 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53198 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53199 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53200 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53201 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53202 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53203 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53204 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53205 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53206 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53207 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53208 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53209 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53210 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53211 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53212 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53213 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53214 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53215 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53216 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53217 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53218 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53219 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53220 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53222 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53223 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53224 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53225 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53226 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53227 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53228 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53229 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53230 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53231 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53232 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53233 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53234 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53235 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53236 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53237 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53238 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53239 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53240 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53241 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53242 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53243 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53244 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53245 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53246 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53247 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53248 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53249 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53250 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53251 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53252 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53253 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53255 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53256 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53258 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53259 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53260 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53261 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53263 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53264 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53265 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53266 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53267 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53268 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53269 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53270 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53271 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53273 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53274 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53275 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53276 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53277 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53278 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53279 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53280 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53281 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53282 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53283 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53284 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53285 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53286 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53287 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53288 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53289 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53290 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53291 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53292 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53293 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53294 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53295 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53296 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53297 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53298 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53299 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53300 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53302 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53303 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53306 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53307 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53308 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53309 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53310 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53311 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53313 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53314 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53317 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53318 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53320 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53321 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53323 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53324 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53326 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53327 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53328 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53330 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53332 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53333 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53335 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53336 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53337 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53339 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53340 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53341 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53343 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53344 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53346 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53347 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53348 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53349 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53350 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53353 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53355 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53357 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53358 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53359 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53362 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53363 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53364 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53366 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53367 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53368 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53370 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53371 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53372 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53373 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53374 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53375 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53377 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53378 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53379 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53380 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53381 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53382 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53383 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53384 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53390 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53392 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53394 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53395 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53396 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53397 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53398 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53399 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53401 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53402 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53404 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53405 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53406 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53409 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53410 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53411 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53414 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53415 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53417 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53418 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53420 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53422 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53425 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53427 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53428 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53430 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53431 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53432 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53434 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53435 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53436 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53438 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53440 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53441 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53442 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53444 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53446 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53448 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53449 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53451 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53452 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53454 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53456 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53457 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53458 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53460 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53462 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53463 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53464 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53466 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53468 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53469 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53470 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53471 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53473 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53475 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53477 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53479 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53480 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53482 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53483 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53484 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53485 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53486 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53487 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53488 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53489 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53491 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53493 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53495 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53497 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53499 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53501 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53502 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53503 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53504 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53505 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53506 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53512 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53513 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53514 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53515 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53516 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53517 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53518 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53520 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53522 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53523 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53525 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53526 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53527 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53528 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53530 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53531 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53532 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53533 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53535 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53536 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53538 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53539 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53540 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53542 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53544 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53545 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53546 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53547 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53548 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53550 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53551 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53552 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53553 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53555 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53556 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53557 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53558 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53559 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53560 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53561 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53562 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53563 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53564 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53566 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53569 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53570 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53571 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53573 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53575 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53577 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53579 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53580 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53590 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53591 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53595 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53596 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53597 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53598 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53599 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53600 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53601 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53602 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53603 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53604 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53605 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53606 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53607 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53608 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53609 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53611 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53612 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53615 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53616 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53621 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53622 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53625 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53626 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53627 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53628 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53631 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53632 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53633 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53635 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53637 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53638 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53639 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53641 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53643 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53645 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53648 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53649 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53650 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53651 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53652 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53653 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53654 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53660 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53661 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53662 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53663 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53670 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53676 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53677 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53678 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53679 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53680 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53682 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53692 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53693 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53694 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53695 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53698 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53699 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53700 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53701 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53703 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53704 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53708 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53714 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53715 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53716 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53717 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53719 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53720 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53722 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53725 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53727 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53728 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53729 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53738 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53742 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53744 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53754 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53755 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53756 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53757 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53761 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53764 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53766 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53769 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53771 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53772 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53775 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53777 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53778 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53779 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53780 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53781 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53786 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53787 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53788 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53790 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53791 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53792 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53794 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53796 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53797 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53798 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53800 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53801 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53804 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53812 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53819 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53827 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53830 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53831 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53844 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53846 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53848 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53849 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53851 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53853 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53854 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53856 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53857 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53858 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53862 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53881 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53882 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53884 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53886 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53887 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53888 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53890 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53891 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53894 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53895 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53897 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53898 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53900 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53903 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53904 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53906 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53908 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53910 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53911 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53913 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53914 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53917 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53919 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53921 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53923 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53926 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53928 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53929 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53930 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53932 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53933 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53934 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53936 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53939 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53941 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53942 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53946 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53950 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53951 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53953 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53957 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53959 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53961 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53962 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53963 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53964 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53968 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53969 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53970 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53971 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53973 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53974 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53979 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53980 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53981 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53982 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53983 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53985 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53987 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53989 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53990 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53992 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53994 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53997 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53998 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53999 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54001 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54002 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54003 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54017 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54018 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54019 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54020 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54021 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54022 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54028 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54029 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54033 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54034 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54036 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54037 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54039 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54041 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54042 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54044 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54045 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54046 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54052 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54053 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54054 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54055 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54056 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54057 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54064 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54066 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54067 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54068 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54069 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54070 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54071 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54073 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54077 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54078 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54079 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54080 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54081 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54082 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54083 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54085 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54086 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54087 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54093 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54094 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54095 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54097 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54098 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54099 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54105 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54106 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54107 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54108 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54109 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54113 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54114 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54119 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54120 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54122 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54123 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54128 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54130 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54131 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54132 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54133 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54134 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54139 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54140 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54149 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54150 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54151 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54152 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54155 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54157 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54158 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54159 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54160 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54162 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54167 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54168 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54169 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54170 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54171 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54172 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54173 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54174 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54175 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54176 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54177 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54179 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54180 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54181 { NULL, NULL, 0, NULL }
54182 };
54183
54184
54185 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54186
54187 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54188 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54189 }
54190 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54191 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54192 }
54193 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54194 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54195 }
54196 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54197 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54198 }
54199 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54200 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54201 }
54202 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54203 return (void *)((wxSizer *) ((wxGridSizer *) x));
54204 }
54205 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54206 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54207 }
54208 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54209 return (void *)((wxSizer *) ((wxPySizer *) x));
54210 }
54211 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54212 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54213 }
54214 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54215 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54216 }
54217 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54218 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54219 }
54220 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54221 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54222 }
54223 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54224 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54225 }
54226 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54227 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54228 }
54229 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54230 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54231 }
54232 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54233 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54234 }
54235 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54236 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54237 }
54238 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54239 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54240 }
54241 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54242 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54243 }
54244 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54245 return (void *)((wxEvent *) ((wxPyEvent *) x));
54246 }
54247 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54248 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54249 }
54250 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54251 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54252 }
54253 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54254 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54255 }
54256 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54257 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54258 }
54259 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54260 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54261 }
54262 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54263 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54264 }
54265 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54266 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54267 }
54268 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54269 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54270 }
54271 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54272 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54273 }
54274 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54275 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54276 }
54277 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54278 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54279 }
54280 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54281 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54282 }
54283 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54284 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54285 }
54286 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54287 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54288 }
54289 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54290 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54291 }
54292 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54293 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54294 }
54295 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54296 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54297 }
54298 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54299 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54300 }
54301 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54302 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54303 }
54304 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54305 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54306 }
54307 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54308 return (void *)((wxEvent *) ((wxShowEvent *) x));
54309 }
54310 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54311 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54312 }
54313 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54314 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54315 }
54316 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54317 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54318 }
54319 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54320 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54321 }
54322 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54323 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54324 }
54325 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54326 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54327 }
54328 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54329 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54330 }
54331 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54332 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54333 }
54334 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54335 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54336 }
54337 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54338 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54339 }
54340 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54341 return (void *)((wxControl *) ((wxControlWithItems *) x));
54342 }
54343 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54344 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54345 }
54346 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54347 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54348 }
54349 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54350 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54351 }
54352 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54353 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54354 }
54355 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54356 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54357 }
54358 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54359 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54360 }
54361 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54362 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54363 }
54364 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54365 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54366 }
54367 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54368 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54369 }
54370 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54371 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54372 }
54373 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54374 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54375 }
54376 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54377 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54378 }
54379 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54380 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54381 }
54382 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54383 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54384 }
54385 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54386 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54387 }
54388 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54389 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54390 }
54391 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54392 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54393 }
54394 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54395 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54396 }
54397 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54398 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54399 }
54400 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54401 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54402 }
54403 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54404 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54405 }
54406 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54407 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54408 }
54409 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54410 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54411 }
54412 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54413 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54414 }
54415 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54416 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54417 }
54418 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54419 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54420 }
54421 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54422 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54423 }
54424 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54425 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54426 }
54427 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54428 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54429 }
54430 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54431 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54432 }
54433 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54434 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54435 }
54436 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54437 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54438 }
54439 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54440 return (void *)((wxObject *) ((wxSizerItem *) x));
54441 }
54442 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54443 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54444 }
54445 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54446 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54447 }
54448 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54449 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54450 }
54451 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54452 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54453 }
54454 static void *_p_wxSizerTo_p_wxObject(void *x) {
54455 return (void *)((wxObject *) ((wxSizer *) x));
54456 }
54457 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54458 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54459 }
54460 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54461 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54462 }
54463 static void *_p_wxEventTo_p_wxObject(void *x) {
54464 return (void *)((wxObject *) ((wxEvent *) x));
54465 }
54466 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54467 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54468 }
54469 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54470 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54471 }
54472 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54473 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54474 }
54475 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54476 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54477 }
54478 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54479 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54480 }
54481 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54482 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54483 }
54484 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54485 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54486 }
54487 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54488 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54489 }
54490 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54491 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54492 }
54493 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54494 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54495 }
54496 static void *_p_wxControlTo_p_wxObject(void *x) {
54497 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54498 }
54499 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54500 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54501 }
54502 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54503 return (void *)((wxObject *) ((wxFSFile *) x));
54504 }
54505 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54506 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54507 }
54508 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54509 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54510 }
54511 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54512 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54513 }
54514 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54515 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54516 }
54517 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54518 return (void *)((wxObject *) ((wxMenuItem *) x));
54519 }
54520 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54521 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54522 }
54523 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54524 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54525 }
54526 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54527 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54528 }
54529 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54530 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54531 }
54532 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54533 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54534 }
54535 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54536 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54537 }
54538 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54539 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54540 }
54541 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54543 }
54544 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54546 }
54547 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54549 }
54550 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54552 }
54553 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54555 }
54556 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54558 }
54559 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54561 }
54562 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54564 }
54565 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54567 }
54568 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54570 }
54571 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54573 }
54574 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54576 }
54577 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) ((wxImageHandler *) x));
54579 }
54580 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54582 }
54583 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54585 }
54586 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) ((wxEvtHandler *) x));
54588 }
54589 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54591 }
54592 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54594 }
54595 static void *_p_wxImageTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) ((wxImage *) x));
54597 }
54598 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54600 }
54601 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54603 }
54604 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54606 }
54607 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54609 }
54610 static void *_p_wxWindowTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54612 }
54613 static void *_p_wxMenuTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54615 }
54616 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54618 }
54619 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) ((wxFileSystem *) x));
54621 }
54622 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54624 }
54625 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54627 }
54628 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54630 }
54631 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54633 }
54634 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54636 }
54637 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54639 }
54640 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54642 }
54643 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54645 }
54646 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54648 }
54649 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54651 }
54652 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54654 }
54655 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54657 }
54658 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54660 }
54661 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54662 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54663 }
54664 static void *_p_wxControlTo_p_wxWindow(void *x) {
54665 return (void *)((wxWindow *) ((wxControl *) x));
54666 }
54667 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54668 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54669 }
54670 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54671 return (void *)((wxWindow *) ((wxMenuBar *) x));
54672 }
54673 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54674 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54675 }
54676 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54677 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54678 }
54679 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54680 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54681 }
54682 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54683 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54684 }
54685 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54686 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54687 }
54688 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54689 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54690 }
54691 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54692 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54693 }
54694 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54695 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54696 }
54697 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54698 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54699 }
54700 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54701 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54702 }
54703 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54704 return (void *)((wxValidator *) ((wxPyValidator *) x));
54705 }
54706 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54707 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54708 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};
54709 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54710 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54837
54838 static swig_type_info *swig_type_initial[] = {
54839 &_swigt__p_buffer,
54840 &_swigt__p_char,
54841 &_swigt__p_form_ops_t,
54842 &_swigt__p_int,
54843 &_swigt__p_long,
54844 &_swigt__p_unsigned_char,
54845 &_swigt__p_unsigned_int,
54846 &_swigt__p_unsigned_long,
54847 &_swigt__p_wxANIHandler,
54848 &_swigt__p_wxAcceleratorEntry,
54849 &_swigt__p_wxAcceleratorTable,
54850 &_swigt__p_wxActivateEvent,
54851 &_swigt__p_wxAppTraits,
54852 &_swigt__p_wxArrayString,
54853 &_swigt__p_wxBMPHandler,
54854 &_swigt__p_wxBitmap,
54855 &_swigt__p_wxBoxSizer,
54856 &_swigt__p_wxButton,
54857 &_swigt__p_wxCURHandler,
54858 &_swigt__p_wxCaret,
54859 &_swigt__p_wxChildFocusEvent,
54860 &_swigt__p_wxClipboardTextEvent,
54861 &_swigt__p_wxCloseEvent,
54862 &_swigt__p_wxColour,
54863 &_swigt__p_wxCommandEvent,
54864 &_swigt__p_wxContextMenuEvent,
54865 &_swigt__p_wxControl,
54866 &_swigt__p_wxControlWithItems,
54867 &_swigt__p_wxCursor,
54868 &_swigt__p_wxDC,
54869 &_swigt__p_wxDateEvent,
54870 &_swigt__p_wxDateTime,
54871 &_swigt__p_wxDisplayChangedEvent,
54872 &_swigt__p_wxDropFilesEvent,
54873 &_swigt__p_wxDuplexMode,
54874 &_swigt__p_wxEraseEvent,
54875 &_swigt__p_wxEvent,
54876 &_swigt__p_wxEventLoop,
54877 &_swigt__p_wxEventLoopActivator,
54878 &_swigt__p_wxEvtHandler,
54879 &_swigt__p_wxFSFile,
54880 &_swigt__p_wxFileSystem,
54881 &_swigt__p_wxFileSystemHandler,
54882 &_swigt__p_wxFlexGridSizer,
54883 &_swigt__p_wxFocusEvent,
54884 &_swigt__p_wxFont,
54885 &_swigt__p_wxFrame,
54886 &_swigt__p_wxGBPosition,
54887 &_swigt__p_wxGBSizerItem,
54888 &_swigt__p_wxGBSpan,
54889 &_swigt__p_wxGIFHandler,
54890 &_swigt__p_wxGridBagSizer,
54891 &_swigt__p_wxGridSizer,
54892 &_swigt__p_wxHelpEvent__Origin,
54893 &_swigt__p_wxICOHandler,
54894 &_swigt__p_wxIconizeEvent,
54895 &_swigt__p_wxIdleEvent,
54896 &_swigt__p_wxImage,
54897 &_swigt__p_wxImageHandler,
54898 &_swigt__p_wxImageHistogram,
54899 &_swigt__p_wxImage_HSVValue,
54900 &_swigt__p_wxImage_RGBValue,
54901 &_swigt__p_wxIndividualLayoutConstraint,
54902 &_swigt__p_wxInitDialogEvent,
54903 &_swigt__p_wxInputStream,
54904 &_swigt__p_wxInternetFSHandler,
54905 &_swigt__p_wxItemContainer,
54906 &_swigt__p_wxJPEGHandler,
54907 &_swigt__p_wxKeyEvent,
54908 &_swigt__p_wxLayoutConstraints,
54909 &_swigt__p_wxMaximizeEvent,
54910 &_swigt__p_wxMemoryFSHandler,
54911 &_swigt__p_wxMenu,
54912 &_swigt__p_wxMenuBar,
54913 &_swigt__p_wxMenuBarBase,
54914 &_swigt__p_wxMenuEvent,
54915 &_swigt__p_wxMenuItem,
54916 &_swigt__p_wxMouseCaptureChangedEvent,
54917 &_swigt__p_wxMouseEvent,
54918 &_swigt__p_wxMoveEvent,
54919 &_swigt__p_wxNavigationKeyEvent,
54920 &_swigt__p_wxNcPaintEvent,
54921 &_swigt__p_wxNotifyEvent,
54922 &_swigt__p_wxObject,
54923 &_swigt__p_wxOutputStream,
54924 &_swigt__p_wxPCXHandler,
54925 &_swigt__p_wxPNGHandler,
54926 &_swigt__p_wxPNMHandler,
54927 &_swigt__p_wxPaintEvent,
54928 &_swigt__p_wxPaletteChangedEvent,
54929 &_swigt__p_wxPaperSize,
54930 &_swigt__p_wxPoint,
54931 &_swigt__p_wxPoint2D,
54932 &_swigt__p_wxPropagateOnce,
54933 &_swigt__p_wxPropagationDisabler,
54934 &_swigt__p_wxPyApp,
54935 &_swigt__p_wxPyCommandEvent,
54936 &_swigt__p_wxPyDropTarget,
54937 &_swigt__p_wxPyEvent,
54938 &_swigt__p_wxPyFileSystemHandler,
54939 &_swigt__p_wxPyImageHandler,
54940 &_swigt__p_wxPyInputStream,
54941 &_swigt__p_wxPySizer,
54942 &_swigt__p_wxPyValidator,
54943 &_swigt__p_wxQuantize,
54944 &_swigt__p_wxQueryNewPaletteEvent,
54945 &_swigt__p_wxRealPoint,
54946 &_swigt__p_wxRect,
54947 &_swigt__p_wxRegion,
54948 &_swigt__p_wxScrollEvent,
54949 &_swigt__p_wxScrollWinEvent,
54950 &_swigt__p_wxSetCursorEvent,
54951 &_swigt__p_wxShowEvent,
54952 &_swigt__p_wxSize,
54953 &_swigt__p_wxSizeEvent,
54954 &_swigt__p_wxSizer,
54955 &_swigt__p_wxSizerItem,
54956 &_swigt__p_wxStaticBox,
54957 &_swigt__p_wxStaticBoxSizer,
54958 &_swigt__p_wxStdDialogButtonSizer,
54959 &_swigt__p_wxSysColourChangedEvent,
54960 &_swigt__p_wxTIFFHandler,
54961 &_swigt__p_wxToolTip,
54962 &_swigt__p_wxUpdateUIEvent,
54963 &_swigt__p_wxValidator,
54964 &_swigt__p_wxVisualAttributes,
54965 &_swigt__p_wxWindow,
54966 &_swigt__p_wxWindowCreateEvent,
54967 &_swigt__p_wxWindowDestroyEvent,
54968 &_swigt__p_wxXPMHandler,
54969 &_swigt__p_wxZipFSHandler,
54970 };
54971
54972 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54973 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54976 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54977 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54978 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54979 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54980 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54982 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54983 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54984 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54985 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54986 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}};
54987 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54988 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}};
54989 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54990 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}};
54991 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54992 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54993 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54994 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54995 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54996 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54998 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}};
54999 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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}};
55009 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55011 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}};
55012 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55013 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55014 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}};
55015 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}};
55016 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55021 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55022 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55023 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55024 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}};
55025 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55026 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}};
55027 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55028 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55030 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}};
55031 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55038 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}};
55039 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55047 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55054 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55055 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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_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_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_wxPNMHandler, _p_wxPNMHandlerTo_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}};
55056 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55057 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55083 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55084 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55085 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55087 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}};
55088 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}};
55089 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55096 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}};
55097 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55098 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}};
55099 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55103
55104 static swig_cast_info *swig_cast_initial[] = {
55105 _swigc__p_buffer,
55106 _swigc__p_char,
55107 _swigc__p_form_ops_t,
55108 _swigc__p_int,
55109 _swigc__p_long,
55110 _swigc__p_unsigned_char,
55111 _swigc__p_unsigned_int,
55112 _swigc__p_unsigned_long,
55113 _swigc__p_wxANIHandler,
55114 _swigc__p_wxAcceleratorEntry,
55115 _swigc__p_wxAcceleratorTable,
55116 _swigc__p_wxActivateEvent,
55117 _swigc__p_wxAppTraits,
55118 _swigc__p_wxArrayString,
55119 _swigc__p_wxBMPHandler,
55120 _swigc__p_wxBitmap,
55121 _swigc__p_wxBoxSizer,
55122 _swigc__p_wxButton,
55123 _swigc__p_wxCURHandler,
55124 _swigc__p_wxCaret,
55125 _swigc__p_wxChildFocusEvent,
55126 _swigc__p_wxClipboardTextEvent,
55127 _swigc__p_wxCloseEvent,
55128 _swigc__p_wxColour,
55129 _swigc__p_wxCommandEvent,
55130 _swigc__p_wxContextMenuEvent,
55131 _swigc__p_wxControl,
55132 _swigc__p_wxControlWithItems,
55133 _swigc__p_wxCursor,
55134 _swigc__p_wxDC,
55135 _swigc__p_wxDateEvent,
55136 _swigc__p_wxDateTime,
55137 _swigc__p_wxDisplayChangedEvent,
55138 _swigc__p_wxDropFilesEvent,
55139 _swigc__p_wxDuplexMode,
55140 _swigc__p_wxEraseEvent,
55141 _swigc__p_wxEvent,
55142 _swigc__p_wxEventLoop,
55143 _swigc__p_wxEventLoopActivator,
55144 _swigc__p_wxEvtHandler,
55145 _swigc__p_wxFSFile,
55146 _swigc__p_wxFileSystem,
55147 _swigc__p_wxFileSystemHandler,
55148 _swigc__p_wxFlexGridSizer,
55149 _swigc__p_wxFocusEvent,
55150 _swigc__p_wxFont,
55151 _swigc__p_wxFrame,
55152 _swigc__p_wxGBPosition,
55153 _swigc__p_wxGBSizerItem,
55154 _swigc__p_wxGBSpan,
55155 _swigc__p_wxGIFHandler,
55156 _swigc__p_wxGridBagSizer,
55157 _swigc__p_wxGridSizer,
55158 _swigc__p_wxHelpEvent__Origin,
55159 _swigc__p_wxICOHandler,
55160 _swigc__p_wxIconizeEvent,
55161 _swigc__p_wxIdleEvent,
55162 _swigc__p_wxImage,
55163 _swigc__p_wxImageHandler,
55164 _swigc__p_wxImageHistogram,
55165 _swigc__p_wxImage_HSVValue,
55166 _swigc__p_wxImage_RGBValue,
55167 _swigc__p_wxIndividualLayoutConstraint,
55168 _swigc__p_wxInitDialogEvent,
55169 _swigc__p_wxInputStream,
55170 _swigc__p_wxInternetFSHandler,
55171 _swigc__p_wxItemContainer,
55172 _swigc__p_wxJPEGHandler,
55173 _swigc__p_wxKeyEvent,
55174 _swigc__p_wxLayoutConstraints,
55175 _swigc__p_wxMaximizeEvent,
55176 _swigc__p_wxMemoryFSHandler,
55177 _swigc__p_wxMenu,
55178 _swigc__p_wxMenuBar,
55179 _swigc__p_wxMenuBarBase,
55180 _swigc__p_wxMenuEvent,
55181 _swigc__p_wxMenuItem,
55182 _swigc__p_wxMouseCaptureChangedEvent,
55183 _swigc__p_wxMouseEvent,
55184 _swigc__p_wxMoveEvent,
55185 _swigc__p_wxNavigationKeyEvent,
55186 _swigc__p_wxNcPaintEvent,
55187 _swigc__p_wxNotifyEvent,
55188 _swigc__p_wxObject,
55189 _swigc__p_wxOutputStream,
55190 _swigc__p_wxPCXHandler,
55191 _swigc__p_wxPNGHandler,
55192 _swigc__p_wxPNMHandler,
55193 _swigc__p_wxPaintEvent,
55194 _swigc__p_wxPaletteChangedEvent,
55195 _swigc__p_wxPaperSize,
55196 _swigc__p_wxPoint,
55197 _swigc__p_wxPoint2D,
55198 _swigc__p_wxPropagateOnce,
55199 _swigc__p_wxPropagationDisabler,
55200 _swigc__p_wxPyApp,
55201 _swigc__p_wxPyCommandEvent,
55202 _swigc__p_wxPyDropTarget,
55203 _swigc__p_wxPyEvent,
55204 _swigc__p_wxPyFileSystemHandler,
55205 _swigc__p_wxPyImageHandler,
55206 _swigc__p_wxPyInputStream,
55207 _swigc__p_wxPySizer,
55208 _swigc__p_wxPyValidator,
55209 _swigc__p_wxQuantize,
55210 _swigc__p_wxQueryNewPaletteEvent,
55211 _swigc__p_wxRealPoint,
55212 _swigc__p_wxRect,
55213 _swigc__p_wxRegion,
55214 _swigc__p_wxScrollEvent,
55215 _swigc__p_wxScrollWinEvent,
55216 _swigc__p_wxSetCursorEvent,
55217 _swigc__p_wxShowEvent,
55218 _swigc__p_wxSize,
55219 _swigc__p_wxSizeEvent,
55220 _swigc__p_wxSizer,
55221 _swigc__p_wxSizerItem,
55222 _swigc__p_wxStaticBox,
55223 _swigc__p_wxStaticBoxSizer,
55224 _swigc__p_wxStdDialogButtonSizer,
55225 _swigc__p_wxSysColourChangedEvent,
55226 _swigc__p_wxTIFFHandler,
55227 _swigc__p_wxToolTip,
55228 _swigc__p_wxUpdateUIEvent,
55229 _swigc__p_wxValidator,
55230 _swigc__p_wxVisualAttributes,
55231 _swigc__p_wxWindow,
55232 _swigc__p_wxWindowCreateEvent,
55233 _swigc__p_wxWindowDestroyEvent,
55234 _swigc__p_wxXPMHandler,
55235 _swigc__p_wxZipFSHandler,
55236 };
55237
55238
55239 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55240
55241 static swig_const_info swig_const_table[] = {
55242 {0, 0, 0, 0.0, 0, 0}};
55243
55244 #ifdef __cplusplus
55245 }
55246 #endif
55247 /* -----------------------------------------------------------------------------
55248 * Type initialization:
55249 * This problem is tough by the requirement that no dynamic
55250 * memory is used. Also, since swig_type_info structures store pointers to
55251 * swig_cast_info structures and swig_cast_info structures store pointers back
55252 * to swig_type_info structures, we need some lookup code at initialization.
55253 * The idea is that swig generates all the structures that are needed.
55254 * The runtime then collects these partially filled structures.
55255 * The SWIG_InitializeModule function takes these initial arrays out of
55256 * swig_module, and does all the lookup, filling in the swig_module.types
55257 * array with the correct data and linking the correct swig_cast_info
55258 * structures together.
55259 *
55260 * The generated swig_type_info structures are assigned staticly to an initial
55261 * array. We just loop though that array, and handle each type individually.
55262 * First we lookup if this type has been already loaded, and if so, use the
55263 * loaded structure instead of the generated one. Then we have to fill in the
55264 * cast linked list. The cast data is initially stored in something like a
55265 * two-dimensional array. Each row corresponds to a type (there are the same
55266 * number of rows as there are in the swig_type_initial array). Each entry in
55267 * a column is one of the swig_cast_info structures for that type.
55268 * The cast_initial array is actually an array of arrays, because each row has
55269 * a variable number of columns. So to actually build the cast linked list,
55270 * we find the array of casts associated with the type, and loop through it
55271 * adding the casts to the list. The one last trick we need to do is making
55272 * sure the type pointer in the swig_cast_info struct is correct.
55273 *
55274 * First off, we lookup the cast->type name to see if it is already loaded.
55275 * There are three cases to handle:
55276 * 1) If the cast->type has already been loaded AND the type we are adding
55277 * casting info to has not been loaded (it is in this module), THEN we
55278 * replace the cast->type pointer with the type pointer that has already
55279 * been loaded.
55280 * 2) If BOTH types (the one we are adding casting info to, and the
55281 * cast->type) are loaded, THEN the cast info has already been loaded by
55282 * the previous module so we just ignore it.
55283 * 3) Finally, if cast->type has not already been loaded, then we add that
55284 * swig_cast_info to the linked list (because the cast->type) pointer will
55285 * be correct.
55286 * ----------------------------------------------------------------------------- */
55287
55288 #ifdef __cplusplus
55289 extern "C" {
55290 #if 0
55291 } /* c-mode */
55292 #endif
55293 #endif
55294
55295 #if 0
55296 #define SWIGRUNTIME_DEBUG
55297 #endif
55298
55299 SWIGRUNTIME void
55300 SWIG_InitializeModule(void *clientdata) {
55301 size_t i;
55302 swig_module_info *module_head;
55303 static int init_run = 0;
55304
55305 clientdata = clientdata;
55306
55307 if (init_run) return;
55308 init_run = 1;
55309
55310 /* Initialize the swig_module */
55311 swig_module.type_initial = swig_type_initial;
55312 swig_module.cast_initial = swig_cast_initial;
55313
55314 /* Try and load any already created modules */
55315 module_head = SWIG_GetModule(clientdata);
55316 if (module_head) {
55317 swig_module.next = module_head->next;
55318 module_head->next = &swig_module;
55319 } else {
55320 /* This is the first module loaded */
55321 swig_module.next = &swig_module;
55322 SWIG_SetModule(clientdata, &swig_module);
55323 }
55324
55325 /* Now work on filling in swig_module.types */
55326 #ifdef SWIGRUNTIME_DEBUG
55327 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55328 #endif
55329 for (i = 0; i < swig_module.size; ++i) {
55330 swig_type_info *type = 0;
55331 swig_type_info *ret;
55332 swig_cast_info *cast;
55333
55334 #ifdef SWIGRUNTIME_DEBUG
55335 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55336 #endif
55337
55338 /* if there is another module already loaded */
55339 if (swig_module.next != &swig_module) {
55340 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55341 }
55342 if (type) {
55343 /* Overwrite clientdata field */
55344 #ifdef SWIGRUNTIME_DEBUG
55345 printf("SWIG_InitializeModule: found type %s\n", type->name);
55346 #endif
55347 if (swig_module.type_initial[i]->clientdata) {
55348 type->clientdata = swig_module.type_initial[i]->clientdata;
55349 #ifdef SWIGRUNTIME_DEBUG
55350 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55351 #endif
55352 }
55353 } else {
55354 type = swig_module.type_initial[i];
55355 }
55356
55357 /* Insert casting types */
55358 cast = swig_module.cast_initial[i];
55359 while (cast->type) {
55360 /* Don't need to add information already in the list */
55361 ret = 0;
55362 #ifdef SWIGRUNTIME_DEBUG
55363 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55364 #endif
55365 if (swig_module.next != &swig_module) {
55366 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55367 #ifdef SWIGRUNTIME_DEBUG
55368 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55369 #endif
55370 }
55371 if (ret) {
55372 if (type == swig_module.type_initial[i]) {
55373 #ifdef SWIGRUNTIME_DEBUG
55374 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55375 #endif
55376 cast->type = ret;
55377 ret = 0;
55378 } else {
55379 /* Check for casting already in the list */
55380 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55381 #ifdef SWIGRUNTIME_DEBUG
55382 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55383 #endif
55384 if (!ocast) ret = 0;
55385 }
55386 }
55387
55388 if (!ret) {
55389 #ifdef SWIGRUNTIME_DEBUG
55390 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55391 #endif
55392 if (type->cast) {
55393 type->cast->prev = cast;
55394 cast->next = type->cast;
55395 }
55396 type->cast = cast;
55397 }
55398 cast++;
55399 }
55400 /* Set entry in modules->types array equal to the type */
55401 swig_module.types[i] = type;
55402 }
55403 swig_module.types[i] = 0;
55404
55405 #ifdef SWIGRUNTIME_DEBUG
55406 printf("**** SWIG_InitializeModule: Cast List ******\n");
55407 for (i = 0; i < swig_module.size; ++i) {
55408 int j = 0;
55409 swig_cast_info *cast = swig_module.cast_initial[i];
55410 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55411 while (cast->type) {
55412 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55413 cast++;
55414 ++j;
55415 }
55416 printf("---- Total casts: %d\n",j);
55417 }
55418 printf("**** SWIG_InitializeModule: Cast List ******\n");
55419 #endif
55420 }
55421
55422 /* This function will propagate the clientdata field of type to
55423 * any new swig_type_info structures that have been added into the list
55424 * of equivalent types. It is like calling
55425 * SWIG_TypeClientData(type, clientdata) a second time.
55426 */
55427 SWIGRUNTIME void
55428 SWIG_PropagateClientData(void) {
55429 size_t i;
55430 swig_cast_info *equiv;
55431 static int init_run = 0;
55432
55433 if (init_run) return;
55434 init_run = 1;
55435
55436 for (i = 0; i < swig_module.size; i++) {
55437 if (swig_module.types[i]->clientdata) {
55438 equiv = swig_module.types[i]->cast;
55439 while (equiv) {
55440 if (!equiv->converter) {
55441 if (equiv->type && !equiv->type->clientdata)
55442 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55443 }
55444 equiv = equiv->next;
55445 }
55446 }
55447 }
55448 }
55449
55450 #ifdef __cplusplus
55451 #if 0
55452 {
55453 /* c-mode */
55454 #endif
55455 }
55456 #endif
55457
55458
55459
55460 #ifdef __cplusplus
55461 extern "C" {
55462 #endif
55463
55464 /* Python-specific SWIG API */
55465 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55466 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55467 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55468
55469 /* -----------------------------------------------------------------------------
55470 * global variable support code.
55471 * ----------------------------------------------------------------------------- */
55472
55473 typedef struct swig_globalvar {
55474 char *name; /* Name of global variable */
55475 PyObject *(*get_attr)(void); /* Return the current value */
55476 int (*set_attr)(PyObject *); /* Set the value */
55477 struct swig_globalvar *next;
55478 } swig_globalvar;
55479
55480 typedef struct swig_varlinkobject {
55481 PyObject_HEAD
55482 swig_globalvar *vars;
55483 } swig_varlinkobject;
55484
55485 SWIGINTERN PyObject *
55486 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55487 return PyString_FromString("<Swig global variables>");
55488 }
55489
55490 SWIGINTERN PyObject *
55491 swig_varlink_str(swig_varlinkobject *v) {
55492 PyObject *str = PyString_FromString("(");
55493 swig_globalvar *var;
55494 for (var = v->vars; var; var=var->next) {
55495 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55496 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55497 }
55498 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55499 return str;
55500 }
55501
55502 SWIGINTERN int
55503 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55504 PyObject *str = swig_varlink_str(v);
55505 fprintf(fp,"Swig global variables ");
55506 fprintf(fp,"%s\n", PyString_AsString(str));
55507 Py_DECREF(str);
55508 return 0;
55509 }
55510
55511 SWIGINTERN void
55512 swig_varlink_dealloc(swig_varlinkobject *v) {
55513 swig_globalvar *var = v->vars;
55514 while (var) {
55515 swig_globalvar *n = var->next;
55516 free(var->name);
55517 free(var);
55518 var = n;
55519 }
55520 }
55521
55522 SWIGINTERN PyObject *
55523 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55524 PyObject *res = NULL;
55525 swig_globalvar *var = v->vars;
55526 while (var) {
55527 if (strcmp(var->name,n) == 0) {
55528 res = (*var->get_attr)();
55529 break;
55530 }
55531 var = var->next;
55532 }
55533 if (res == NULL && !PyErr_Occurred()) {
55534 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55535 }
55536 return res;
55537 }
55538
55539 SWIGINTERN int
55540 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55541 int res = 1;
55542 swig_globalvar *var = v->vars;
55543 while (var) {
55544 if (strcmp(var->name,n) == 0) {
55545 res = (*var->set_attr)(p);
55546 break;
55547 }
55548 var = var->next;
55549 }
55550 if (res == 1 && !PyErr_Occurred()) {
55551 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55552 }
55553 return res;
55554 }
55555
55556 SWIGINTERN PyTypeObject*
55557 swig_varlink_type(void) {
55558 static char varlink__doc__[] = "Swig var link object";
55559 static PyTypeObject varlink_type;
55560 static int type_init = 0;
55561 if (!type_init) {
55562 const PyTypeObject tmp
55563 = {
55564 PyObject_HEAD_INIT(NULL)
55565 0, /* Number of items in variable part (ob_size) */
55566 (char *)"swigvarlink", /* Type name (tp_name) */
55567 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55568 0, /* Itemsize (tp_itemsize) */
55569 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55570 (printfunc) swig_varlink_print, /* Print (tp_print) */
55571 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55572 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55573 0, /* tp_compare */
55574 (reprfunc) swig_varlink_repr, /* tp_repr */
55575 0, /* tp_as_number */
55576 0, /* tp_as_sequence */
55577 0, /* tp_as_mapping */
55578 0, /* tp_hash */
55579 0, /* tp_call */
55580 (reprfunc)swig_varlink_str, /* tp_str */
55581 0, /* tp_getattro */
55582 0, /* tp_setattro */
55583 0, /* tp_as_buffer */
55584 0, /* tp_flags */
55585 varlink__doc__, /* tp_doc */
55586 0, /* tp_traverse */
55587 0, /* tp_clear */
55588 0, /* tp_richcompare */
55589 0, /* tp_weaklistoffset */
55590 #if PY_VERSION_HEX >= 0x02020000
55591 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55592 #endif
55593 #if PY_VERSION_HEX >= 0x02030000
55594 0, /* tp_del */
55595 #endif
55596 #ifdef COUNT_ALLOCS
55597 0,0,0,0 /* tp_alloc -> tp_next */
55598 #endif
55599 };
55600 varlink_type = tmp;
55601 varlink_type.ob_type = &PyType_Type;
55602 type_init = 1;
55603 }
55604 return &varlink_type;
55605 }
55606
55607 /* Create a variable linking object for use later */
55608 SWIGINTERN PyObject *
55609 SWIG_Python_newvarlink(void) {
55610 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55611 if (result) {
55612 result->vars = 0;
55613 }
55614 return ((PyObject*) result);
55615 }
55616
55617 SWIGINTERN void
55618 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55619 swig_varlinkobject *v = (swig_varlinkobject *) p;
55620 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55621 if (gv) {
55622 size_t size = strlen(name)+1;
55623 gv->name = (char *)malloc(size);
55624 if (gv->name) {
55625 strncpy(gv->name,name,size);
55626 gv->get_attr = get_attr;
55627 gv->set_attr = set_attr;
55628 gv->next = v->vars;
55629 }
55630 }
55631 v->vars = gv;
55632 }
55633
55634 SWIGINTERN PyObject *
55635 SWIG_globals() {
55636 static PyObject *_SWIG_globals = 0;
55637 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55638 return _SWIG_globals;
55639 }
55640
55641 /* -----------------------------------------------------------------------------
55642 * constants/methods manipulation
55643 * ----------------------------------------------------------------------------- */
55644
55645 /* Install Constants */
55646 SWIGINTERN void
55647 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55648 PyObject *obj = 0;
55649 size_t i;
55650 for (i = 0; constants[i].type; ++i) {
55651 switch(constants[i].type) {
55652 case SWIG_PY_POINTER:
55653 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55654 break;
55655 case SWIG_PY_BINARY:
55656 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55657 break;
55658 default:
55659 obj = 0;
55660 break;
55661 }
55662 if (obj) {
55663 PyDict_SetItemString(d, constants[i].name, obj);
55664 Py_DECREF(obj);
55665 }
55666 }
55667 }
55668
55669 /* -----------------------------------------------------------------------------*/
55670 /* Fix SwigMethods to carry the callback ptrs when needed */
55671 /* -----------------------------------------------------------------------------*/
55672
55673 SWIGINTERN void
55674 SWIG_Python_FixMethods(PyMethodDef *methods,
55675 swig_const_info *const_table,
55676 swig_type_info **types,
55677 swig_type_info **types_initial) {
55678 size_t i;
55679 for (i = 0; methods[i].ml_name; ++i) {
55680 const char *c = methods[i].ml_doc;
55681 if (c && (c = strstr(c, "swig_ptr: "))) {
55682 int j;
55683 swig_const_info *ci = 0;
55684 const char *name = c + 10;
55685 for (j = 0; const_table[j].type; ++j) {
55686 if (strncmp(const_table[j].name, name,
55687 strlen(const_table[j].name)) == 0) {
55688 ci = &(const_table[j]);
55689 break;
55690 }
55691 }
55692 if (ci) {
55693 size_t shift = (ci->ptype) - types;
55694 swig_type_info *ty = types_initial[shift];
55695 size_t ldoc = (c - methods[i].ml_doc);
55696 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55697 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55698 if (ndoc) {
55699 char *buff = ndoc;
55700 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55701 if (ptr) {
55702 strncpy(buff, methods[i].ml_doc, ldoc);
55703 buff += ldoc;
55704 strncpy(buff, "swig_ptr: ", 10);
55705 buff += 10;
55706 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55707 methods[i].ml_doc = ndoc;
55708 }
55709 }
55710 }
55711 }
55712 }
55713 }
55714
55715 #ifdef __cplusplus
55716 }
55717 #endif
55718
55719 /* -----------------------------------------------------------------------------*
55720 * Partial Init method
55721 * -----------------------------------------------------------------------------*/
55722
55723 #ifdef __cplusplus
55724 extern "C"
55725 #endif
55726 SWIGEXPORT void SWIG_init(void) {
55727 PyObject *m, *d;
55728
55729 /* Fix SwigMethods to carry the callback ptrs when needed */
55730 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55731
55732 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55733 d = PyModule_GetDict(m);
55734
55735 SWIG_InitializeModule(0);
55736 SWIG_InstallConstants(d,swig_const_table);
55737
55738
55739
55740 #ifndef wxPyUSE_EXPORT
55741 // Make our API structure a CObject so other modules can import it
55742 // from this module.
55743 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55744 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55745 Py_XDECREF(cobj);
55746 #endif
55747
55748 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55749 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55750 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55751 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55752 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55753 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55754 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55755 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55756 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55757 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55758 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55759 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55760 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55761 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55762 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55763 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55764 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55765 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55766 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55767 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55768 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55769 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55770 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55771 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55772 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55773 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55774 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55775 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55776 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55777 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55778 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55779 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55780 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55781 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55782 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55783 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55784 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55785 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55786 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55787 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55788 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55789 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55790 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55791 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55792 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55793 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55794 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55795 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55796 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55797 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55798 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55799 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55800 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55801 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55802 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55803 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55804 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55805 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55806 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55807 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55808 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55809 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55810 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55811 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55812 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55813 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55814 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55815 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55816 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55817 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55818 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55819 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55820 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55821 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55822 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55823 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55824 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55825 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55826 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55827 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55828 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55829 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55830 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55831 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55832 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55833 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55834 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55835 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55836 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55837 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55838 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55839 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55840 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55841 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55842 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55843 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55844 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55845 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55846 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55847 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55848 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55849 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55850 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55851 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55852 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55853 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55854 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55855 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55856 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55857 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55858 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55859 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55860 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55861 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55862 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55863 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55864 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55865 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55866 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55867 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55868 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55869 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55870 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55871 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55872 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55873 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55874 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55875 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55876 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55877 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55878 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55879 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55880 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55881 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55882 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55883 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55884 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55885 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55886 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55887 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55888 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55889 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55890 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55891 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55892 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55893 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55894 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55895 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55896 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55897 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55898 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55899 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55900 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55901 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55902 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55903 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55904 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55905 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55906 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55907 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55908 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55909 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55910 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55911 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55912 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55913 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55914 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55915 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55916 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55917 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55918 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55919 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55920 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55921 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55922 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55923 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55924 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55925 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55926 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55927 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55928 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55929 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55930 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55931 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55932 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55933 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55934 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55935 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55936 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55937 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55938 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55939 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55940 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55941 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55942 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55943 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55944 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55945 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55946 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55947 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55948 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55949 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55950 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55951 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55952 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55953 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55954 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55955 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55956 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55957 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55958 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55959 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55960 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55961 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55962 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55963 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55964 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55965 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55966 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55967 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55968 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55969 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55970 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55971 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55972 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55973 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55974 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55975 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55976 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55977 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55978 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55979 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55980 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55981 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55982 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55983 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55984 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55985 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55986 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55987 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55988 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55989 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55990 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55991 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55992 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55993 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55994 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55995 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55996 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55997 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55998 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55999 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56000 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56001 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56002 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56003 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56004 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56005 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56006 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56007 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56008 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56009 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56010 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56011 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56012 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56013 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56014 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56015 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56016 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56017 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56018 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56019 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56020 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56021 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56022 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56023 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56024 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56025 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56026 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56027 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56028 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56029 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56030 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56031 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56032 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56033 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56034 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56035 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56036 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56037 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56038 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56039 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56040 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56041 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56042 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56043 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56044 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56045 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56046 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56047 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56048 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56049 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56050 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56051 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56052 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56053 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56054 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56055 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56056 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56057 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56058 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56059 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56060 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56061 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56062 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56063 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56064 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56065 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56066 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56067 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56068 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56069 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56070 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56071 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56072 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56073 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56074 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56075 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56076 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56077 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56078 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56079 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56080 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56081 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56082 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56083 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56084 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56085 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56086 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56087 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56088 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56089 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56090 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56091 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56092 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56093 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56094 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56095 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56096 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56097 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56098 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56099 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56100 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56101 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56102 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56103 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56104 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56105 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56106 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56107 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56108 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56109 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56110 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56111 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56112 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56113 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56114 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56115 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56116 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56117 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56118 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56119 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56120 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56121 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56122 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56123 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56124 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56125 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56126 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56127 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56128 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56129 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56130 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56131 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56132 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56133 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56134 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56135 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56136 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56137 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56138 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56139 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56140 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56141 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56142 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56143 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56144 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56145 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56146 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56147 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56148 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56163 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56164 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56165 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56166 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56167 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56168 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56169 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56170 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56171 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56172 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56173 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56174 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56175 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56176 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56177 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56178 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56179 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56180 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56181 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56182 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56183 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56184 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56185 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56186 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56187 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56188 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56189 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56190 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56191 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56192 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56193 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56194 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56195 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56196 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56197 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56198 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56199 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56200 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56201 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56202 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56203 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56204 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56205 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56206 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56207 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56208 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56209 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56210 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56211 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56212 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56213 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56214 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56215 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56216 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56217 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56218 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56219 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56220 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56221 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56222 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56223 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56224 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56225 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56226 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56227 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56228 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56229 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56230 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56231 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56232 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56233 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56234 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56235 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56236 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56237 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56238 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56239 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56240 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56241 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56242 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56243 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56244 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56245 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56246 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56247 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56248 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56249 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56250 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56251 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56252 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56253 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56254 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56255 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56256 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56257 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56258 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56259 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56260 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56261 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56262 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56263 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56264 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56265 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56266 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56267 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56268 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56269 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56270 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56271 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56272 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56273 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56274 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56275 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56276 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56277 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56278 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56279 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56280 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56281 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56282 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56283 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56284 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56285 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56286 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56287 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56288 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56289 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56290 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56291 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56292 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56293 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56294 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56295 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56296 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56297 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56298 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56299 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56300 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56301 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56302 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56303 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56304 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56305 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56310 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56312 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56313 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56314 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56315 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56316 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56317 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56318 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56319 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56320 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56321 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56322 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56323 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56324 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56325 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56326 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56327 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56328 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56329 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56330 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56331 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56332 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56333 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56334 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56335 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56336 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56337 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56338 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56339 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56340 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56341 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56342 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56343 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56344 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56345 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56346 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56347 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56348 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56349 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56350 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56351 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56352 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56353 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56354 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56355 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56362 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56363 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56364 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56365 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56366 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56367 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56368 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56369 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56370 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56371 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56372 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56373 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56374 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56375 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56376 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56377 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56378 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56379 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56380 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56381 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56382 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56383 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56384 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56385 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56386 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56387 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56388 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56389 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56390 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56391 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56392 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56393 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56394 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56395 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56396 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56397 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56398 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56399 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56400 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56401 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56402 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56403 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56404 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56405 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56406 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56407 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56408 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56409 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56410 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56411
56412 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56413
56414
56415 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56416
56417 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56418 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56419 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56420 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56421 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56423 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56424 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56425 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56426 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56427 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56428 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56430 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56431 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56432 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56433 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56434 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56435 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56436 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56437 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56438 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56439 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56440 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56441 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56442 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56443 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56444 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56445 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56446 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56447 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56448 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56449 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56450 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56451 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56452 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56453 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56454 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56455 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56456 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56457 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56458 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56459 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56460 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56461 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56462 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56463 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56464 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56465 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56466 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56467 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56468 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56469 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56470 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56471 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56472 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56473 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56474 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56475 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56476 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56477 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56478 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56479 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56480 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56481 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56482 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56483 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56484 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56485 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56486 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56487 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56488 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56489 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56490 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56491 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56492 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56493 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56494 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56495 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56496 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56497 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56498 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56499 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56500 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56501 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56502 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56503 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56504 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56505 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56506 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56507 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56508 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56509 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56510 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56511 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56512 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56513 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56514 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56515 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56516 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56517 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56518 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56519 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56520 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56521 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56522 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56523 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56524 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56525 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56526 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56527 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56528 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56529 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56530 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56531 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56532 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56533 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56534 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56535 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56536 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56537 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56538 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56539 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56540 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56541 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56542 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56543 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56544 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56545 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56546 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56547 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56548 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56549 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56550 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56551 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56552 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56553 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56554 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56555 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56556 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56557 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56558 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56559 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56560 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56565 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56566 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56567 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56568 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56569 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56570 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56571 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56572 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56573 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56574 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56575 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56576 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56577 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56578 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56579 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56580 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56581 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56582 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56583 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56584 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56585 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56586 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56587 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56588 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56589 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56590 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56591 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56592 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56593 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56594 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56595 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56596 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56597 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56598 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56599 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56600 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56601 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56602 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56603 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56604 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56605 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56606 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56607 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56608 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56609 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56610 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56611 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56612 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56613 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56614 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56615 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56616 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56617 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56618 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56619 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56620 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56621 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56622 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56623
56624 // Initialize threading, some globals and such
56625 __wxPyPreStart(d);
56626
56627
56628 // Although these are defined in __version__ they need to be here too so
56629 // that an assert can be done to ensure that the wxPython and the wxWindows
56630 // versions match.
56631 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56632 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56633 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56634
56635 }
56636
wxWidgets (Impactor)