]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
compile fixes for Python 2.5
[wxWidgets.git] / wxPython / src / gtk / _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_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 int result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (int)((wxRect const *)arg1)->GetLeft();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_From_int(static_cast< int >(result));
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 int result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)((wxRect const *)arg1)->GetTop();
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_From_int(static_cast< int >(result));
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (int)((wxRect const *)arg1)->GetBottom();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_From_int(static_cast< int >(result));
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxRect *arg1 = (wxRect *) 0 ;
6915 int result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (int)((wxRect const *)arg1)->GetRight();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int arg2 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 int val2 ;
6947 int ecode2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "left", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6958 }
6959 arg1 = reinterpret_cast< wxRect * >(argp1);
6960 ecode2 = SWIG_AsVal_int(obj1, &val2);
6961 if (!SWIG_IsOK(ecode2)) {
6962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6963 }
6964 arg2 = static_cast< int >(val2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetLeft(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 int arg2 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int val2 ;
6985 int ecode2 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "self",(char *) "right", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 ecode2 = SWIG_AsVal_int(obj1, &val2);
6999 if (!SWIG_IsOK(ecode2)) {
7000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7001 }
7002 arg2 = static_cast< int >(val2);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 (arg1)->SetRight(arg2);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 int arg2 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "top", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 (arg1)->SetTop(arg2);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int arg2 ;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 int val2 ;
7061 int ecode2 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "bottom", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 (arg1)->SetBottom(arg2);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int arg2 ;
7096 int arg3 ;
7097 wxRect *result = 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 int val2 ;
7101 int ecode2 = 0 ;
7102 int val3 ;
7103 int ecode3 = 0 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 PyObject * obj2 = 0 ;
7107 char * kwnames[] = {
7108 (char *) "self",(char *) "dx",(char *) "dy", NULL
7109 };
7110
7111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 ecode2 = SWIG_AsVal_int(obj1, &val2);
7118 if (!SWIG_IsOK(ecode2)) {
7119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7120 }
7121 arg2 = static_cast< int >(val2);
7122 ecode3 = SWIG_AsVal_int(obj2, &val3);
7123 if (!SWIG_IsOK(ecode3)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7125 }
7126 arg3 = static_cast< int >(val3);
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 {
7130 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7131 result = (wxRect *) &_result_ref;
7132 }
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 int arg3 ;
7148 wxRect *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 int val2 ;
7152 int ecode2 = 0 ;
7153 int val3 ;
7154 int ecode3 = 0 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 PyObject * obj2 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "dx",(char *) "dy", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 ecode3 = SWIG_AsVal_int(obj2, &val3);
7174 if (!SWIG_IsOK(ecode3)) {
7175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7176 }
7177 arg3 = static_cast< int >(val3);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 {
7181 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7182 result = (wxRect *) &_result_ref;
7183 }
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 int arg2 ;
7198 int arg3 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 int val3 ;
7204 int ecode3 = 0 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 PyObject * obj2 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "dx",(char *) "dy", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 ecode2 = SWIG_AsVal_int(obj1, &val2);
7219 if (!SWIG_IsOK(ecode2)) {
7220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7221 }
7222 arg2 = static_cast< int >(val2);
7223 ecode3 = SWIG_AsVal_int(obj2, &val3);
7224 if (!SWIG_IsOK(ecode3)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7226 }
7227 arg3 = static_cast< int >(val3);
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset(arg2,arg3);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxPoint *arg2 = 0 ;
7245 void *argp1 = 0 ;
7246 int res1 = 0 ;
7247 wxPoint temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 {
7261 arg2 = &temp2;
7262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Offset((wxPoint const &)*arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 wxRect *arg2 = 0 ;
7281 wxRect result;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 wxRect temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "rect", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 {
7298 arg2 = &temp2;
7299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7300 }
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (arg1)->Intersect((wxRect const &)*arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 wxRect *arg2 = 0 ;
7318 wxRect result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 wxRect temp2 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char * kwnames[] = {
7325 (char *) "self",(char *) "rect", NULL
7326 };
7327
7328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7332 }
7333 arg1 = reinterpret_cast< wxRect * >(argp1);
7334 {
7335 arg2 = &temp2;
7336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7337 }
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (arg1)->Union((wxRect const &)*arg2);
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxRect *arg2 = 0 ;
7355 wxRect result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 wxRect temp2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "rect", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 {
7372 arg2 = &temp2;
7373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxRect *arg1 = (wxRect *) 0 ;
7391 wxRect *arg2 = 0 ;
7392 wxRect *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 wxRect temp2 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "rect", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 {
7409 arg2 = &temp2;
7410 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 {
7415 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7416 result = (wxRect *) &_result_ref;
7417 }
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj = 0;
7430 wxRect *arg1 = (wxRect *) 0 ;
7431 PyObject *arg2 = (PyObject *) 0 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "other", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 arg2 = obj1;
7448 {
7449 result = (bool)wxRect___eq__(arg1,arg2);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 PyObject *arg2 = (PyObject *) 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "other", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7478 }
7479 arg1 = reinterpret_cast< wxRect * >(argp1);
7480 arg2 = obj1;
7481 {
7482 result = (bool)wxRect___ne__(arg1,arg2);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxRect *arg1 = (wxRect *) 0 ;
7497 int arg2 ;
7498 int arg3 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "x",(char *) "y", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 ecode2 = SWIG_AsVal_int(obj1, &val2);
7520 if (!SWIG_IsOK(ecode2)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7522 }
7523 arg2 = static_cast< int >(val2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxPoint *arg2 = 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxPoint temp2 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pt", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7562 }
7563 arg1 = reinterpret_cast< wxRect * >(argp1);
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 {
7604 arg2 = &temp2;
7605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 wxRect temp2 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "rect", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 {
7643 arg2 = &temp2;
7644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7645 }
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxRect *arg1 = (wxRect *) 0 ;
7664 wxRect *arg2 = 0 ;
7665 int arg3 = (int) wxBOTH ;
7666 wxRect result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 wxRect temp2 ;
7670 int val3 ;
7671 int ecode3 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "r",(char *) "dir", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 {
7686 arg2 = &temp2;
7687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7688 }
7689 if (obj2) {
7690 ecode3 = SWIG_AsVal_int(obj2, &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7693 }
7694 arg3 = static_cast< int >(val3);
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->x = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->x);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->y = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->y);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->width = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->width);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->height = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->height);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 = (int) 0 ;
7925 int arg3 = (int) 0 ;
7926 int arg4 = (int) 0 ;
7927 int arg5 = (int) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 int val2 ;
7931 int ecode2 = 0 ;
7932 int val3 ;
7933 int ecode3 = 0 ;
7934 int val4 ;
7935 int ecode4 = 0 ;
7936 int val5 ;
7937 int ecode5 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 PyObject * obj2 = 0 ;
7941 PyObject * obj3 = 0 ;
7942 PyObject * obj4 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7951 }
7952 arg1 = reinterpret_cast< wxRect * >(argp1);
7953 if (obj1) {
7954 ecode2 = SWIG_AsVal_int(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7957 }
7958 arg2 = static_cast< int >(val2);
7959 }
7960 if (obj2) {
7961 ecode3 = SWIG_AsVal_int(obj2, &val3);
7962 if (!SWIG_IsOK(ecode3)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7964 }
7965 arg3 = static_cast< int >(val3);
7966 }
7967 if (obj3) {
7968 ecode4 = SWIG_AsVal_int(obj3, &val4);
7969 if (!SWIG_IsOK(ecode4)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7971 }
7972 arg4 = static_cast< int >(val4);
7973 }
7974 if (obj4) {
7975 ecode5 = SWIG_AsVal_int(obj4, &val5);
7976 if (!SWIG_IsOK(ecode5)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7978 }
7979 arg5 = static_cast< int >(val5);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 PyObject *result = 0 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (PyObject *)wxRect_Get(arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = result;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *obj;
8024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8025 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8026 return SWIG_Py_Void();
8027 }
8028
8029 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 return SWIG_Python_InitShadowInstance(args);
8031 }
8032
8033 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 wxRect *arg2 = (wxRect *) 0 ;
8037 PyObject *result = 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 void *argp2 = 0 ;
8041 int res2 = 0 ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "r1",(char *) "r2", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res2)) {
8056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8057 }
8058 arg2 = reinterpret_cast< wxRect * >(argp2);
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 result = (PyObject *)wxIntersectRect(arg1,arg2);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = result;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 double arg1 = (double) 0.0 ;
8076 double arg2 = (double) 0.0 ;
8077 wxPoint2D *result = 0 ;
8078 double val1 ;
8079 int ecode1 = 0 ;
8080 double val2 ;
8081 int ecode2 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 char * kwnames[] = {
8085 (char *) "x",(char *) "y", NULL
8086 };
8087
8088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8089 if (obj0) {
8090 ecode1 = SWIG_AsVal_double(obj0, &val1);
8091 if (!SWIG_IsOK(ecode1)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8093 }
8094 arg1 = static_cast< double >(val1);
8095 }
8096 if (obj1) {
8097 ecode2 = SWIG_AsVal_double(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8100 }
8101 arg2 = static_cast< double >(val2);
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 wxPoint2D *arg1 = 0 ;
8119 wxPoint2D *result = 0 ;
8120 wxPoint2D temp1 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "pt", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8127 {
8128 arg1 = &temp1;
8129 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxPoint *arg1 = 0 ;
8147 wxPoint2D *result = 0 ;
8148 wxPoint temp1 ;
8149 PyObject * obj0 = 0 ;
8150 char * kwnames[] = {
8151 (char *) "pt", NULL
8152 };
8153
8154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8155 {
8156 arg1 = &temp1;
8157 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8158 }
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 int *arg2 = (int *) 0 ;
8176 int *arg3 = (int *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int temp2 ;
8180 int res2 = SWIG_TMPOBJ ;
8181 int temp3 ;
8182 int res3 = SWIG_TMPOBJ ;
8183 PyObject *swig_obj[1] ;
8184
8185 arg2 = &temp2;
8186 arg3 = &temp3;
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8192 }
8193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 if (SWIG_IsTmpObj(res2)) {
8202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8203 } else {
8204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8206 }
8207 if (SWIG_IsTmpObj(res3)) {
8208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8209 } else {
8210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 int *arg2 = (int *) 0 ;
8223 int *arg3 = (int *) 0 ;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 int temp2 ;
8227 int res2 = SWIG_TMPOBJ ;
8228 int temp3 ;
8229 int res3 = SWIG_TMPOBJ ;
8230 PyObject *swig_obj[1] ;
8231
8232 arg2 = &temp2;
8233 arg3 = &temp3;
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8239 }
8240 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 if (SWIG_IsTmpObj(res2)) {
8249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8250 } else {
8251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8253 }
8254 if (SWIG_IsTmpObj(res3)) {
8255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8256 } else {
8257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8259 }
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 PyObject *swig_obj[1] ;
8273
8274 if (!args) SWIG_fail;
8275 swig_obj[0] = args;
8276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8279 }
8280 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_From_double(static_cast< double >(result));
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 double result;
8298 void *argp1 = 0 ;
8299 int res1 = 0 ;
8300 PyObject *swig_obj[1] ;
8301
8302 if (!args) SWIG_fail;
8303 swig_obj[0] = args;
8304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8305 if (!SWIG_IsOK(res1)) {
8306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8307 }
8308 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_From_double(static_cast< double >(result));
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 double arg2 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 double val2 ;
8329 int ecode2 = 0 ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 char * kwnames[] = {
8333 (char *) "self",(char *) "length", NULL
8334 };
8335
8336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8338 if (!SWIG_IsOK(res1)) {
8339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8340 }
8341 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8342 ecode2 = SWIG_AsVal_double(obj1, &val2);
8343 if (!SWIG_IsOK(ecode2)) {
8344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8345 }
8346 arg2 = static_cast< double >(val2);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->SetVectorLength(arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_Py_Void();
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 double arg2 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 double val2 ;
8367 int ecode2 = 0 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "degrees", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 ecode2 = SWIG_AsVal_double(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8383 }
8384 arg2 = static_cast< double >(val2);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 (arg1)->SetVectorAngle(arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "pt", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "pt", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D *arg2 = 0 ;
8476 double result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 wxPoint2D temp2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "vec", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 arg2 = &temp2;
8494 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8495 }
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_From_double(static_cast< double >(result));
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8512 wxPoint2D *arg2 = 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 wxPoint2D temp2 ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char * kwnames[] = {
8520 (char *) "self",(char *) "vec", NULL
8521 };
8522
8523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8527 }
8528 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 wxPoint2D result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->operator -();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 wxPoint2D *arg2 = 0 ;
8618 wxPoint2D *result = 0 ;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 wxPoint2D temp2 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "pt", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 {
8635 arg2 = &temp2;
8636 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 {
8641 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8642 result = (wxPoint2D *) &_result_ref;
8643 }
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8657 wxPoint2D *arg2 = 0 ;
8658 wxPoint2D *result = 0 ;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 wxPoint2D temp2 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "pt", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8672 }
8673 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8674 {
8675 arg2 = &temp2;
8676 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 {
8681 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8682 result = (wxPoint2D *) &_result_ref;
8683 }
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 wxPoint2D *result = 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pt", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 {
8721 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8722 result = (wxPoint2D *) &_result_ref;
8723 }
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 PyObject *arg2 = (PyObject *) 0 ;
8738 bool result;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "other", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 arg2 = obj1;
8754 {
8755 result = (bool)wxPoint2D___eq__(arg1,arg2);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8760 }
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 PyObject *arg2 = (PyObject *) 0 ;
8771 bool result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "other", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 arg2 = obj1;
8787 {
8788 result = (bool)wxPoint2D___ne__(arg1,arg2);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 PyObject *swig_obj[2] ;
8809
8810 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8819 }
8820 arg2 = static_cast< double >(val2);
8821 if (arg1) (arg1)->m_x = arg2;
8822
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 double result;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 PyObject *swig_obj[1] ;
8837
8838 if (!args) SWIG_fail;
8839 swig_obj[0] = args;
8840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 result = (double) ((arg1)->m_x);
8846 resultobj = SWIG_From_double(static_cast< double >(result));
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 double arg2 ;
8857 void *argp1 = 0 ;
8858 int res1 = 0 ;
8859 double val2 ;
8860 int ecode2 = 0 ;
8861 PyObject *swig_obj[2] ;
8862
8863 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8867 }
8868 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8872 }
8873 arg2 = static_cast< double >(val2);
8874 if (arg1) (arg1)->m_y = arg2;
8875
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 double result;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 result = (double) ((arg1)->m_y);
8899 resultobj = SWIG_From_double(static_cast< double >(result));
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double arg2 = (double) 0 ;
8910 double arg3 = (double) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 double val2 ;
8914 int ecode2 = 0 ;
8915 double val3 ;
8916 int ecode3 = 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 PyObject * obj2 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "self",(char *) "x",(char *) "y", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8930 if (obj1) {
8931 ecode2 = SWIG_AsVal_double(obj1, &val2);
8932 if (!SWIG_IsOK(ecode2)) {
8933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8934 }
8935 arg2 = static_cast< double >(val2);
8936 }
8937 if (obj2) {
8938 ecode3 = SWIG_AsVal_double(obj2, &val3);
8939 if (!SWIG_IsOK(ecode3)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8941 }
8942 arg3 = static_cast< double >(val3);
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxPoint2D_Set(arg1,arg2,arg3);
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 PyObject *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (PyObject *)wxPoint2D_Get(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = result;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN int DefaultPosition_set(PyObject *) {
8997 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8998 return 1;
8999 }
9000
9001
9002 SWIGINTERN PyObject *DefaultPosition_get(void) {
9003 PyObject *pyobj = 0;
9004
9005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9006 return pyobj;
9007 }
9008
9009
9010 SWIGINTERN int DefaultSize_set(PyObject *) {
9011 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9012 return 1;
9013 }
9014
9015
9016 SWIGINTERN PyObject *DefaultSize_get(void) {
9017 PyObject *pyobj = 0;
9018
9019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9020 return pyobj;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj = 0;
9026 PyObject *arg1 = (PyObject *) 0 ;
9027 wxPyInputStream *result = 0 ;
9028 PyObject * obj0 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "p", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9034 arg1 = obj0;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_Py_Void();
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 (arg1)->close();
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109
9110 if (!args) SWIG_fail;
9111 swig_obj[0] = args;
9112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9113 if (!SWIG_IsOK(res1)) {
9114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9115 }
9116 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 (arg1)->flush();
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9133 bool result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->eof();
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 {
9152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 int arg2 = (int) -1 ;
9164 PyObject *result = 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 int val2 ;
9168 int ecode2 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "size", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_int(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9185 }
9186 arg2 = static_cast< int >(val2);
9187 }
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (PyObject *)(arg1)->read(arg2);
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = result;
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9204 int arg2 = (int) -1 ;
9205 PyObject *result = 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 int val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "size", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9220 }
9221 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (PyObject *)(arg1)->readline(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = result;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 int arg2 = (int) -1 ;
9246 PyObject *result = 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 int val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "sizehint", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9261 }
9262 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_int(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9267 }
9268 arg2 = static_cast< int >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (PyObject *)(arg1)->readlines(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = result;
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 int arg2 ;
9287 int arg3 = (int) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 int val2 ;
9291 int ecode2 = 0 ;
9292 int val3 ;
9293 int ecode3 = 0 ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char * kwnames[] = {
9298 (char *) "self",(char *) "offset",(char *) "whence", NULL
9299 };
9300
9301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9305 }
9306 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9307 ecode2 = SWIG_AsVal_int(obj1, &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9310 }
9311 arg2 = static_cast< int >(val2);
9312 if (obj2) {
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->seek(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *resultobj = 0;
9334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9335 int result;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 PyObject *swig_obj[1] ;
9339
9340 if (!args) SWIG_fail;
9341 swig_obj[0] = args;
9342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9345 }
9346 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (int)(arg1)->tell();
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_From_int(static_cast< int >(result));
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9363 char result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (char)(arg1)->Peek();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_char(static_cast< char >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 PyObject *swig_obj[1] ;
9395
9396 if (!args) SWIG_fail;
9397 swig_obj[0] = args;
9398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (char)(arg1)->GetC();
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_From_char(static_cast< char >(result));
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 size_t result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (size_t)(arg1)->LastRead();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 bool result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanRead();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 {
9466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9467 }
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9477 bool result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9487 }
9488 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (bool)(arg1)->Eof();
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 {
9496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9497 }
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 char arg2 ;
9508 bool result;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 char val2 ;
9512 int ecode2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "c", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9523 }
9524 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9525 ecode2 = SWIG_AsVal_char(obj1, &val2);
9526 if (!SWIG_IsOK(ecode2)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9528 }
9529 arg2 = static_cast< char >(val2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (bool)(arg1)->Ungetch(arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 {
9537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj = 0;
9547 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9548 long arg2 ;
9549 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9550 long result;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 long val2 ;
9554 int ecode2 = 0 ;
9555 int val3 ;
9556 int ecode3 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "pos",(char *) "mode", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9568 }
9569 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9570 ecode2 = SWIG_AsVal_long(obj1, &val2);
9571 if (!SWIG_IsOK(ecode2)) {
9572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9573 }
9574 arg2 = static_cast< long >(val2);
9575 if (obj2) {
9576 ecode3 = SWIG_AsVal_int(obj2, &val3);
9577 if (!SWIG_IsOK(ecode3)) {
9578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9579 }
9580 arg3 = static_cast< wxSeekMode >(val3);
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (long)(arg1)->SeekI(arg2,arg3);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_long(static_cast< long >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 PyObject *resultobj = 0;
9597 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9598 long result;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 PyObject *swig_obj[1] ;
9602
9603 if (!args) SWIG_fail;
9604 swig_obj[0] = args;
9605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9608 }
9609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (long)(arg1)->TellI();
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_From_long(static_cast< long >(result));
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *obj;
9625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9627 return SWIG_Py_Void();
9628 }
9629
9630 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9631 return SWIG_Python_InitShadowInstance(args);
9632 }
9633
9634 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9637 PyObject *arg2 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "obj", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 wxOutputStream_write(arg1,arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9669 size_t result;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9679 }
9680 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxInputStream *arg1 = (wxInputStream *) 0 ;
9704 wxString *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxString *arg4 = 0 ;
9707 wxDateTime arg5 ;
9708 wxFSFile *result = 0 ;
9709 wxPyInputStream *temp1 ;
9710 bool temp2 = false ;
9711 bool temp3 = false ;
9712 bool temp4 = false ;
9713 void *argp5 ;
9714 int res5 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 PyObject * obj2 = 0 ;
9718 PyObject * obj3 = 0 ;
9719 PyObject * obj4 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9725 {
9726 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9727 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9728 } else {
9729 PyErr_Clear(); // clear the failure of the wxPyConvert above
9730 arg1 = wxPyCBInputStream_create(obj0, true);
9731 if (arg1 == NULL) {
9732 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9733 SWIG_fail;
9734 }
9735 }
9736 }
9737 {
9738 arg2 = wxString_in_helper(obj1);
9739 if (arg2 == NULL) SWIG_fail;
9740 temp2 = true;
9741 }
9742 {
9743 arg3 = wxString_in_helper(obj2);
9744 if (arg3 == NULL) SWIG_fail;
9745 temp3 = true;
9746 }
9747 {
9748 arg4 = wxString_in_helper(obj3);
9749 if (arg4 == NULL) SWIG_fail;
9750 temp4 = true;
9751 }
9752 {
9753 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9754 if (!SWIG_IsOK(res5)) {
9755 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9756 }
9757 if (!argp5) {
9758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9759 } else {
9760 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9761 arg5 = *temp;
9762 if (SWIG_IsNewObj(res5)) delete temp;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9772 {
9773 if (temp2)
9774 delete arg2;
9775 }
9776 {
9777 if (temp3)
9778 delete arg3;
9779 }
9780 {
9781 if (temp4)
9782 delete arg4;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp2)
9788 delete arg2;
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 {
9795 if (temp4)
9796 delete arg4;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9803 PyObject *resultobj = 0;
9804 wxFSFile *arg1 = (wxFSFile *) 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9814 }
9815 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 delete arg1;
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 resultobj = SWIG_Py_Void();
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9831 PyObject *resultobj = 0;
9832 wxFSFile *arg1 = (wxFSFile *) 0 ;
9833 wxInputStream *result = 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxInputStream *)(arg1)->GetStream();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 wxPyInputStream * _ptr = NULL;
9853
9854 if (result) {
9855 _ptr = new wxPyInputStream(result);
9856 }
9857 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 wxString *result = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 {
9883 wxString const &_result_ref = (arg1)->GetMimeType();
9884 result = (wxString *) &_result_ref;
9885 }
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 #if wxUSE_UNICODE
9891 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9892 #else
9893 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9894 #endif
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxFSFile *arg1 = (wxFSFile *) 0 ;
9905 wxString *result = 0 ;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9915 }
9916 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 {
9920 wxString const &_result_ref = (arg1)->GetLocation();
9921 result = (wxString *) &_result_ref;
9922 }
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 {
9927 #if wxUSE_UNICODE
9928 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9929 #else
9930 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9931 #endif
9932 }
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9940 PyObject *resultobj = 0;
9941 wxFSFile *arg1 = (wxFSFile *) 0 ;
9942 wxString *result = 0 ;
9943 void *argp1 = 0 ;
9944 int res1 = 0 ;
9945 PyObject *swig_obj[1] ;
9946
9947 if (!args) SWIG_fail;
9948 swig_obj[0] = args;
9949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9950 if (!SWIG_IsOK(res1)) {
9951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9952 }
9953 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 {
9957 wxString const &_result_ref = (arg1)->GetAnchor();
9958 result = (wxString *) &_result_ref;
9959 }
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 #if wxUSE_UNICODE
9965 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9966 #else
9967 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9968 #endif
9969 }
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxFSFile *arg1 = (wxFSFile *) 0 ;
9979 wxDateTime result;
9980 void *argp1 = 0 ;
9981 int res1 = 0 ;
9982 PyObject *swig_obj[1] ;
9983
9984 if (!args) SWIG_fail;
9985 swig_obj[0] = args;
9986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9989 }
9990 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetModificationTime();
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *obj;
10006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10007 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10008 return SWIG_Py_Void();
10009 }
10010
10011 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10012 return SWIG_Python_InitShadowInstance(args);
10013 }
10014
10015 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016 PyObject *resultobj = 0;
10017 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10018 void *argp1 = 0 ;
10019 int res1 = 0 ;
10020 PyObject *swig_obj[1] ;
10021
10022 if (!args) SWIG_fail;
10023 swig_obj[0] = args;
10024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10027 }
10028 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10029 {
10030 PyThreadState* __tstate = wxPyBeginAllowThreads();
10031 delete arg1;
10032
10033 wxPyEndAllowThreads(__tstate);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *obj;
10045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10046 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10047 return SWIG_Py_Void();
10048 }
10049
10050 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10051 PyObject *resultobj = 0;
10052 wxPyFileSystemHandler *result = 0 ;
10053
10054 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10071 PyObject *arg2 = (PyObject *) 0 ;
10072 PyObject *arg3 = (PyObject *) 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 PyObject * obj2 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "self",(char *) "_class", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10086 }
10087 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10088 arg2 = obj1;
10089 arg3 = obj2;
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 (arg1)->_setCallbackInfo(arg2,arg3);
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10106 wxString *arg2 = 0 ;
10107 bool result;
10108 void *argp1 = 0 ;
10109 int res1 = 0 ;
10110 bool temp2 = false ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char * kwnames[] = {
10114 (char *) "self",(char *) "location", NULL
10115 };
10116
10117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10119 if (!SWIG_IsOK(res1)) {
10120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10121 }
10122 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10123 {
10124 arg2 = wxString_in_helper(obj1);
10125 if (arg2 == NULL) SWIG_fail;
10126 temp2 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 {
10135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10136 }
10137 {
10138 if (temp2)
10139 delete arg2;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj = 0;
10153 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10154 wxFileSystem *arg2 = 0 ;
10155 wxString *arg3 = 0 ;
10156 wxFSFile *result = 0 ;
10157 void *argp1 = 0 ;
10158 int res1 = 0 ;
10159 void *argp2 = 0 ;
10160 int res2 = 0 ;
10161 bool temp3 = false ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 PyObject * obj2 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "self",(char *) "fs",(char *) "location", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10176 if (!SWIG_IsOK(res2)) {
10177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10178 }
10179 if (!argp2) {
10180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10181 }
10182 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10183 {
10184 arg3 = wxString_in_helper(obj2);
10185 if (arg3 == NULL) SWIG_fail;
10186 temp3 = true;
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10196 }
10197 {
10198 if (temp3)
10199 delete arg3;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp3)
10205 delete arg3;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = 0;
10213 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10214 wxString *arg2 = 0 ;
10215 int arg3 = (int) 0 ;
10216 wxString result;
10217 void *argp1 = 0 ;
10218 int res1 = 0 ;
10219 bool temp2 = false ;
10220 int val3 ;
10221 int ecode3 = 0 ;
10222 PyObject * obj0 = 0 ;
10223 PyObject * obj1 = 0 ;
10224 PyObject * obj2 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "spec",(char *) "flags", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10233 }
10234 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10235 {
10236 arg2 = wxString_in_helper(obj1);
10237 if (arg2 == NULL) SWIG_fail;
10238 temp2 = true;
10239 }
10240 if (obj2) {
10241 ecode3 = SWIG_AsVal_int(obj2, &val3);
10242 if (!SWIG_IsOK(ecode3)) {
10243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10244 }
10245 arg3 = static_cast< int >(val3);
10246 }
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 {
10254 #if wxUSE_UNICODE
10255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10256 #else
10257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10258 #endif
10259 }
10260 {
10261 if (temp2)
10262 delete arg2;
10263 }
10264 return resultobj;
10265 fail:
10266 {
10267 if (temp2)
10268 delete arg2;
10269 }
10270 return NULL;
10271 }
10272
10273
10274 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 PyObject *resultobj = 0;
10276 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10277 wxString result;
10278 void *argp1 = 0 ;
10279 int res1 = 0 ;
10280 PyObject *swig_obj[1] ;
10281
10282 if (!args) SWIG_fail;
10283 swig_obj[0] = args;
10284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10285 if (!SWIG_IsOK(res1)) {
10286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10287 }
10288 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10289 {
10290 PyThreadState* __tstate = wxPyBeginAllowThreads();
10291 result = (arg1)->FindNext();
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 {
10296 #if wxUSE_UNICODE
10297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10298 #else
10299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10300 #endif
10301 }
10302 return resultobj;
10303 fail:
10304 return NULL;
10305 }
10306
10307
10308 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10309 PyObject *resultobj = 0;
10310 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10311 wxString *arg2 = 0 ;
10312 wxString result;
10313 void *argp1 = 0 ;
10314 int res1 = 0 ;
10315 bool temp2 = false ;
10316 PyObject * obj0 = 0 ;
10317 PyObject * obj1 = 0 ;
10318 char * kwnames[] = {
10319 (char *) "self",(char *) "location", NULL
10320 };
10321
10322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10324 if (!SWIG_IsOK(res1)) {
10325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10326 }
10327 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10328 {
10329 arg2 = wxString_in_helper(obj1);
10330 if (arg2 == NULL) SWIG_fail;
10331 temp2 = true;
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (arg1)->GetProtocol((wxString const &)*arg2);
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 #if wxUSE_UNICODE
10341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10342 #else
10343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10344 #endif
10345 }
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return resultobj;
10351 fail:
10352 {
10353 if (temp2)
10354 delete arg2;
10355 }
10356 return NULL;
10357 }
10358
10359
10360 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj = 0;
10362 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10363 wxString *arg2 = 0 ;
10364 wxString result;
10365 void *argp1 = 0 ;
10366 int res1 = 0 ;
10367 bool temp2 = false ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char * kwnames[] = {
10371 (char *) "self",(char *) "location", NULL
10372 };
10373
10374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10376 if (!SWIG_IsOK(res1)) {
10377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10378 }
10379 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10380 {
10381 arg2 = wxString_in_helper(obj1);
10382 if (arg2 == NULL) SWIG_fail;
10383 temp2 = true;
10384 }
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10388 wxPyEndAllowThreads(__tstate);
10389 if (PyErr_Occurred()) SWIG_fail;
10390 }
10391 {
10392 #if wxUSE_UNICODE
10393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10394 #else
10395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10396 #endif
10397 }
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return resultobj;
10403 fail:
10404 {
10405 if (temp2)
10406 delete arg2;
10407 }
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj = 0;
10414 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10415 wxString *arg2 = 0 ;
10416 wxString result;
10417 void *argp1 = 0 ;
10418 int res1 = 0 ;
10419 bool temp2 = false ;
10420 PyObject * obj0 = 0 ;
10421 PyObject * obj1 = 0 ;
10422 char * kwnames[] = {
10423 (char *) "self",(char *) "location", NULL
10424 };
10425
10426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10428 if (!SWIG_IsOK(res1)) {
10429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10430 }
10431 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10432 {
10433 arg2 = wxString_in_helper(obj1);
10434 if (arg2 == NULL) SWIG_fail;
10435 temp2 = true;
10436 }
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (arg1)->GetAnchor((wxString const &)*arg2);
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 {
10444 #if wxUSE_UNICODE
10445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10446 #else
10447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10448 #endif
10449 }
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return resultobj;
10455 fail:
10456 {
10457 if (temp2)
10458 delete arg2;
10459 }
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj = 0;
10466 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10467 wxString *arg2 = 0 ;
10468 wxString result;
10469 void *argp1 = 0 ;
10470 int res1 = 0 ;
10471 bool temp2 = false ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 char * kwnames[] = {
10475 (char *) "self",(char *) "location", NULL
10476 };
10477
10478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10482 }
10483 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10484 {
10485 arg2 = wxString_in_helper(obj1);
10486 if (arg2 == NULL) SWIG_fail;
10487 temp2 = true;
10488 }
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 #if wxUSE_UNICODE
10497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10498 #else
10499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10500 #endif
10501 }
10502 {
10503 if (temp2)
10504 delete arg2;
10505 }
10506 return resultobj;
10507 fail:
10508 {
10509 if (temp2)
10510 delete arg2;
10511 }
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj = 0;
10518 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10519 wxString *arg2 = 0 ;
10520 wxString result;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 bool temp2 = false ;
10524 PyObject * obj0 = 0 ;
10525 PyObject * obj1 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "location", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10536 {
10537 arg2 = wxString_in_helper(obj1);
10538 if (arg2 == NULL) SWIG_fail;
10539 temp2 = true;
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 {
10548 #if wxUSE_UNICODE
10549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10550 #else
10551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10552 #endif
10553 }
10554 {
10555 if (temp2)
10556 delete arg2;
10557 }
10558 return resultobj;
10559 fail:
10560 {
10561 if (temp2)
10562 delete arg2;
10563 }
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *obj;
10570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10572 return SWIG_Py_Void();
10573 }
10574
10575 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 return SWIG_Python_InitShadowInstance(args);
10577 }
10578
10579 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *resultobj = 0;
10581 wxFileSystem *result = 0 ;
10582
10583 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxFileSystem *)new wxFileSystem();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 {
10591 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10592 }
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10600 PyObject *resultobj = 0;
10601 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 PyObject *swig_obj[1] ;
10605
10606 if (!args) SWIG_fail;
10607 swig_obj[0] = args;
10608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10611 }
10612 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 delete arg1;
10616
10617 wxPyEndAllowThreads(__tstate);
10618 if (PyErr_Occurred()) SWIG_fail;
10619 }
10620 resultobj = SWIG_Py_Void();
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj = 0;
10629 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10630 wxString *arg2 = 0 ;
10631 bool arg3 = (bool) false ;
10632 void *argp1 = 0 ;
10633 int res1 = 0 ;
10634 bool temp2 = false ;
10635 bool val3 ;
10636 int ecode3 = 0 ;
10637 PyObject * obj0 = 0 ;
10638 PyObject * obj1 = 0 ;
10639 PyObject * obj2 = 0 ;
10640 char * kwnames[] = {
10641 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10642 };
10643
10644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10646 if (!SWIG_IsOK(res1)) {
10647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10648 }
10649 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10650 {
10651 arg2 = wxString_in_helper(obj1);
10652 if (arg2 == NULL) SWIG_fail;
10653 temp2 = true;
10654 }
10655 if (obj2) {
10656 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10657 if (!SWIG_IsOK(ecode3)) {
10658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10659 }
10660 arg3 = static_cast< bool >(val3);
10661 }
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10665 wxPyEndAllowThreads(__tstate);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_Py_Void();
10669 {
10670 if (temp2)
10671 delete arg2;
10672 }
10673 return resultobj;
10674 fail:
10675 {
10676 if (temp2)
10677 delete arg2;
10678 }
10679 return NULL;
10680 }
10681
10682
10683 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10684 PyObject *resultobj = 0;
10685 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10686 wxString result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 PyObject *swig_obj[1] ;
10690
10691 if (!args) SWIG_fail;
10692 swig_obj[0] = args;
10693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10696 }
10697 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10698 {
10699 PyThreadState* __tstate = wxPyBeginAllowThreads();
10700 result = (arg1)->GetPath();
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 {
10705 #if wxUSE_UNICODE
10706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10707 #else
10708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10709 #endif
10710 }
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10718 PyObject *resultobj = 0;
10719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10720 wxString *arg2 = 0 ;
10721 wxFSFile *result = 0 ;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 bool temp2 = false ;
10725 PyObject * obj0 = 0 ;
10726 PyObject * obj1 = 0 ;
10727 char * kwnames[] = {
10728 (char *) "self",(char *) "location", NULL
10729 };
10730
10731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10733 if (!SWIG_IsOK(res1)) {
10734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10735 }
10736 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10737 {
10738 arg2 = wxString_in_helper(obj1);
10739 if (arg2 == NULL) SWIG_fail;
10740 temp2 = true;
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10750 }
10751 {
10752 if (temp2)
10753 delete arg2;
10754 }
10755 return resultobj;
10756 fail:
10757 {
10758 if (temp2)
10759 delete arg2;
10760 }
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj = 0;
10767 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10768 wxString *arg2 = 0 ;
10769 int arg3 = (int) 0 ;
10770 wxString result;
10771 void *argp1 = 0 ;
10772 int res1 = 0 ;
10773 bool temp2 = false ;
10774 int val3 ;
10775 int ecode3 = 0 ;
10776 PyObject * obj0 = 0 ;
10777 PyObject * obj1 = 0 ;
10778 PyObject * obj2 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "spec",(char *) "flags", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10787 }
10788 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10789 {
10790 arg2 = wxString_in_helper(obj1);
10791 if (arg2 == NULL) SWIG_fail;
10792 temp2 = true;
10793 }
10794 if (obj2) {
10795 ecode3 = SWIG_AsVal_int(obj2, &val3);
10796 if (!SWIG_IsOK(ecode3)) {
10797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10798 }
10799 arg3 = static_cast< int >(val3);
10800 }
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 {
10808 #if wxUSE_UNICODE
10809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10810 #else
10811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10812 #endif
10813 }
10814 {
10815 if (temp2)
10816 delete arg2;
10817 }
10818 return resultobj;
10819 fail:
10820 {
10821 if (temp2)
10822 delete arg2;
10823 }
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10829 PyObject *resultobj = 0;
10830 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10831 wxString result;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 PyObject *swig_obj[1] ;
10835
10836 if (!args) SWIG_fail;
10837 swig_obj[0] = args;
10838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10839 if (!SWIG_IsOK(res1)) {
10840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10841 }
10842 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (arg1)->FindNext();
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 {
10850 #if wxUSE_UNICODE
10851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10852 #else
10853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10854 #endif
10855 }
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj = 0;
10864 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10865 int res1 = 0 ;
10866 PyObject * obj0 = 0 ;
10867 char * kwnames[] = {
10868 (char *) "handler", NULL
10869 };
10870
10871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10872 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10873 if (!SWIG_IsOK(res1)) {
10874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10875 }
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 wxFileSystem::AddHandler(arg1);
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_Py_Void();
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891
10892 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10893 {
10894 PyThreadState* __tstate = wxPyBeginAllowThreads();
10895 wxFileSystem::CleanUpHandlers();
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_Py_Void();
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxString *arg1 = 0 ;
10909 wxString result;
10910 bool temp1 = false ;
10911 PyObject * obj0 = 0 ;
10912 char * kwnames[] = {
10913 (char *) "filename", NULL
10914 };
10915
10916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10917 {
10918 arg1 = wxString_in_helper(obj0);
10919 if (arg1 == NULL) SWIG_fail;
10920 temp1 = true;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 #if wxUSE_UNICODE
10930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10931 #else
10932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10933 #endif
10934 }
10935 {
10936 if (temp1)
10937 delete arg1;
10938 }
10939 return resultobj;
10940 fail:
10941 {
10942 if (temp1)
10943 delete arg1;
10944 }
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj = 0;
10951 wxString *arg1 = 0 ;
10952 wxString result;
10953 bool temp1 = false ;
10954 PyObject * obj0 = 0 ;
10955 char * kwnames[] = {
10956 (char *) "url", NULL
10957 };
10958
10959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10960 {
10961 arg1 = wxString_in_helper(obj0);
10962 if (arg1 == NULL) SWIG_fail;
10963 temp1 = true;
10964 }
10965 {
10966 PyThreadState* __tstate = wxPyBeginAllowThreads();
10967 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10968 wxPyEndAllowThreads(__tstate);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 {
10972 #if wxUSE_UNICODE
10973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10974 #else
10975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10976 #endif
10977 }
10978 {
10979 if (temp1)
10980 delete arg1;
10981 }
10982 return resultobj;
10983 fail:
10984 {
10985 if (temp1)
10986 delete arg1;
10987 }
10988 return NULL;
10989 }
10990
10991
10992 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10993 PyObject *obj;
10994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10995 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10996 return SWIG_Py_Void();
10997 }
10998
10999 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11000 return SWIG_Python_InitShadowInstance(args);
11001 }
11002
11003 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 PyObject *resultobj = 0;
11005 wxInternetFSHandler *result = 0 ;
11006
11007 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11015 return resultobj;
11016 fail:
11017 return NULL;
11018 }
11019
11020
11021 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11022 PyObject *resultobj = 0;
11023 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11024 wxString *arg2 = 0 ;
11025 bool result;
11026 void *argp1 = 0 ;
11027 int res1 = 0 ;
11028 bool temp2 = false ;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 char * kwnames[] = {
11032 (char *) "self",(char *) "location", NULL
11033 };
11034
11035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11039 }
11040 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11041 {
11042 arg2 = wxString_in_helper(obj1);
11043 if (arg2 == NULL) SWIG_fail;
11044 temp2 = true;
11045 }
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11049 wxPyEndAllowThreads(__tstate);
11050 if (PyErr_Occurred()) SWIG_fail;
11051 }
11052 {
11053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11054 }
11055 {
11056 if (temp2)
11057 delete arg2;
11058 }
11059 return resultobj;
11060 fail:
11061 {
11062 if (temp2)
11063 delete arg2;
11064 }
11065 return NULL;
11066 }
11067
11068
11069 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11070 PyObject *resultobj = 0;
11071 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11072 wxFileSystem *arg2 = 0 ;
11073 wxString *arg3 = 0 ;
11074 wxFSFile *result = 0 ;
11075 void *argp1 = 0 ;
11076 int res1 = 0 ;
11077 void *argp2 = 0 ;
11078 int res2 = 0 ;
11079 bool temp3 = false ;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 char * kwnames[] = {
11084 (char *) "self",(char *) "fs",(char *) "location", NULL
11085 };
11086
11087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11089 if (!SWIG_IsOK(res1)) {
11090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11091 }
11092 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11094 if (!SWIG_IsOK(res2)) {
11095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11096 }
11097 if (!argp2) {
11098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11099 }
11100 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11101 {
11102 arg3 = wxString_in_helper(obj2);
11103 if (arg3 == NULL) SWIG_fail;
11104 temp3 = true;
11105 }
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11114 }
11115 {
11116 if (temp3)
11117 delete arg3;
11118 }
11119 return resultobj;
11120 fail:
11121 {
11122 if (temp3)
11123 delete arg3;
11124 }
11125 return NULL;
11126 }
11127
11128
11129 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11130 PyObject *obj;
11131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11132 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11133 return SWIG_Py_Void();
11134 }
11135
11136 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11137 return SWIG_Python_InitShadowInstance(args);
11138 }
11139
11140 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxZipFSHandler *result = 0 ;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (wxZipFSHandler *)new wxZipFSHandler();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj = 0;
11160 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11161 wxString *arg2 = 0 ;
11162 bool result;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 bool temp2 = false ;
11166 PyObject * obj0 = 0 ;
11167 PyObject * obj1 = 0 ;
11168 char * kwnames[] = {
11169 (char *) "self",(char *) "location", NULL
11170 };
11171
11172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11174 if (!SWIG_IsOK(res1)) {
11175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11176 }
11177 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11178 {
11179 arg2 = wxString_in_helper(obj1);
11180 if (arg2 == NULL) SWIG_fail;
11181 temp2 = true;
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11191 }
11192 {
11193 if (temp2)
11194 delete arg2;
11195 }
11196 return resultobj;
11197 fail:
11198 {
11199 if (temp2)
11200 delete arg2;
11201 }
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11209 wxFileSystem *arg2 = 0 ;
11210 wxString *arg3 = 0 ;
11211 wxFSFile *result = 0 ;
11212 void *argp1 = 0 ;
11213 int res1 = 0 ;
11214 void *argp2 = 0 ;
11215 int res2 = 0 ;
11216 bool temp3 = false ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "self",(char *) "fs",(char *) "location", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11228 }
11229 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11231 if (!SWIG_IsOK(res2)) {
11232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11233 }
11234 if (!argp2) {
11235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11236 }
11237 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11238 {
11239 arg3 = wxString_in_helper(obj2);
11240 if (arg3 == NULL) SWIG_fail;
11241 temp3 = true;
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11251 }
11252 {
11253 if (temp3)
11254 delete arg3;
11255 }
11256 return resultobj;
11257 fail:
11258 {
11259 if (temp3)
11260 delete arg3;
11261 }
11262 return NULL;
11263 }
11264
11265
11266 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11267 PyObject *resultobj = 0;
11268 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11269 wxString *arg2 = 0 ;
11270 int arg3 = (int) 0 ;
11271 wxString result;
11272 void *argp1 = 0 ;
11273 int res1 = 0 ;
11274 bool temp2 = false ;
11275 int val3 ;
11276 int ecode3 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 char * kwnames[] = {
11281 (char *) "self",(char *) "spec",(char *) "flags", NULL
11282 };
11283
11284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11286 if (!SWIG_IsOK(res1)) {
11287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11288 }
11289 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11290 {
11291 arg2 = wxString_in_helper(obj1);
11292 if (arg2 == NULL) SWIG_fail;
11293 temp2 = true;
11294 }
11295 if (obj2) {
11296 ecode3 = SWIG_AsVal_int(obj2, &val3);
11297 if (!SWIG_IsOK(ecode3)) {
11298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11299 }
11300 arg3 = static_cast< int >(val3);
11301 }
11302 {
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11305 wxPyEndAllowThreads(__tstate);
11306 if (PyErr_Occurred()) SWIG_fail;
11307 }
11308 {
11309 #if wxUSE_UNICODE
11310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11311 #else
11312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11313 #endif
11314 }
11315 {
11316 if (temp2)
11317 delete arg2;
11318 }
11319 return resultobj;
11320 fail:
11321 {
11322 if (temp2)
11323 delete arg2;
11324 }
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11330 PyObject *resultobj = 0;
11331 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11332 wxString result;
11333 void *argp1 = 0 ;
11334 int res1 = 0 ;
11335 PyObject *swig_obj[1] ;
11336
11337 if (!args) SWIG_fail;
11338 swig_obj[0] = args;
11339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11340 if (!SWIG_IsOK(res1)) {
11341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11342 }
11343 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (arg1)->FindNext();
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 #if wxUSE_UNICODE
11352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11353 #else
11354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11355 #endif
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11364 PyObject *obj;
11365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11366 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11367 return SWIG_Py_Void();
11368 }
11369
11370 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 return SWIG_Python_InitShadowInstance(args);
11372 }
11373
11374 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11375 PyObject *resultobj = 0;
11376 wxString *arg1 = 0 ;
11377 wxImage *arg2 = 0 ;
11378 long arg3 ;
11379 bool temp1 = false ;
11380 void *argp2 = 0 ;
11381 int res2 = 0 ;
11382 long val3 ;
11383 int ecode3 = 0 ;
11384 PyObject * obj0 = 0 ;
11385 PyObject * obj1 = 0 ;
11386 PyObject * obj2 = 0 ;
11387 char * kwnames[] = {
11388 (char *) "filename",(char *) "image",(char *) "type", NULL
11389 };
11390
11391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11392 {
11393 arg1 = wxString_in_helper(obj0);
11394 if (arg1 == NULL) SWIG_fail;
11395 temp1 = true;
11396 }
11397 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11398 if (!SWIG_IsOK(res2)) {
11399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11400 }
11401 if (!argp2) {
11402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11403 }
11404 arg2 = reinterpret_cast< wxImage * >(argp2);
11405 ecode3 = SWIG_AsVal_long(obj2, &val3);
11406 if (!SWIG_IsOK(ecode3)) {
11407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11408 }
11409 arg3 = static_cast< long >(val3);
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_Py_Void();
11417 {
11418 if (temp1)
11419 delete arg1;
11420 }
11421 return resultobj;
11422 fail:
11423 {
11424 if (temp1)
11425 delete arg1;
11426 }
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 wxBitmap *arg2 = 0 ;
11435 long arg3 ;
11436 bool temp1 = false ;
11437 void *argp2 = 0 ;
11438 int res2 = 0 ;
11439 long val3 ;
11440 int ecode3 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11460 }
11461 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11462 ecode3 = SWIG_AsVal_long(obj2, &val3);
11463 if (!SWIG_IsOK(ecode3)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11465 }
11466 arg3 = static_cast< long >(val3);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj = 0;
11490 wxString *arg1 = 0 ;
11491 PyObject *arg2 = (PyObject *) 0 ;
11492 bool temp1 = false ;
11493 PyObject * obj0 = 0 ;
11494 PyObject * obj1 = 0 ;
11495 char * kwnames[] = {
11496 (char *) "filename",(char *) "data", NULL
11497 };
11498
11499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11500 {
11501 arg1 = wxString_in_helper(obj0);
11502 if (arg1 == NULL) SWIG_fail;
11503 temp1 = true;
11504 }
11505 arg2 = obj1;
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 resultobj = SWIG_Py_Void();
11513 {
11514 if (temp1)
11515 delete arg1;
11516 }
11517 return resultobj;
11518 fail:
11519 {
11520 if (temp1)
11521 delete arg1;
11522 }
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxMemoryFSHandler *result = 0 ;
11530
11531 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxString *arg1 = 0 ;
11548 bool temp1 = false ;
11549 PyObject * obj0 = 0 ;
11550 char * kwnames[] = {
11551 (char *) "filename", NULL
11552 };
11553
11554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11555 {
11556 arg1 = wxString_in_helper(obj0);
11557 if (arg1 == NULL) SWIG_fail;
11558 temp1 = true;
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_Py_Void();
11567 {
11568 if (temp1)
11569 delete arg1;
11570 }
11571 return resultobj;
11572 fail:
11573 {
11574 if (temp1)
11575 delete arg1;
11576 }
11577 return NULL;
11578 }
11579
11580
11581 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11582 PyObject *resultobj = 0;
11583 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11584 wxString *arg2 = 0 ;
11585 bool result;
11586 void *argp1 = 0 ;
11587 int res1 = 0 ;
11588 bool temp2 = false ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 char * kwnames[] = {
11592 (char *) "self",(char *) "location", NULL
11593 };
11594
11595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11597 if (!SWIG_IsOK(res1)) {
11598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11599 }
11600 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11601 {
11602 arg2 = wxString_in_helper(obj1);
11603 if (arg2 == NULL) SWIG_fail;
11604 temp2 = true;
11605 }
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11614 }
11615 {
11616 if (temp2)
11617 delete arg2;
11618 }
11619 return resultobj;
11620 fail:
11621 {
11622 if (temp2)
11623 delete arg2;
11624 }
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj = 0;
11631 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11632 wxFileSystem *arg2 = 0 ;
11633 wxString *arg3 = 0 ;
11634 wxFSFile *result = 0 ;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 void *argp2 = 0 ;
11638 int res2 = 0 ;
11639 bool temp3 = false ;
11640 PyObject * obj0 = 0 ;
11641 PyObject * obj1 = 0 ;
11642 PyObject * obj2 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "fs",(char *) "location", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11654 if (!SWIG_IsOK(res2)) {
11655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11656 }
11657 if (!argp2) {
11658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11659 }
11660 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11661 {
11662 arg3 = wxString_in_helper(obj2);
11663 if (arg3 == NULL) SWIG_fail;
11664 temp3 = true;
11665 }
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11674 }
11675 {
11676 if (temp3)
11677 delete arg3;
11678 }
11679 return resultobj;
11680 fail:
11681 {
11682 if (temp3)
11683 delete arg3;
11684 }
11685 return NULL;
11686 }
11687
11688
11689 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11692 wxString *arg2 = 0 ;
11693 int arg3 = (int) 0 ;
11694 wxString result;
11695 void *argp1 = 0 ;
11696 int res1 = 0 ;
11697 bool temp2 = false ;
11698 int val3 ;
11699 int ecode3 = 0 ;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "self",(char *) "spec",(char *) "flags", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11711 }
11712 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11713 {
11714 arg2 = wxString_in_helper(obj1);
11715 if (arg2 == NULL) SWIG_fail;
11716 temp2 = true;
11717 }
11718 if (obj2) {
11719 ecode3 = SWIG_AsVal_int(obj2, &val3);
11720 if (!SWIG_IsOK(ecode3)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11722 }
11723 arg3 = static_cast< int >(val3);
11724 }
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 #if wxUSE_UNICODE
11733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11734 #else
11735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11736 #endif
11737 }
11738 {
11739 if (temp2)
11740 delete arg2;
11741 }
11742 return resultobj;
11743 fail:
11744 {
11745 if (temp2)
11746 delete arg2;
11747 }
11748 return NULL;
11749 }
11750
11751
11752 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11753 PyObject *resultobj = 0;
11754 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11755 wxString result;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 PyObject *swig_obj[1] ;
11759
11760 if (!args) SWIG_fail;
11761 swig_obj[0] = args;
11762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11765 }
11766 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (arg1)->FindNext();
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 #if wxUSE_UNICODE
11775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11776 #else
11777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11778 #endif
11779 }
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *obj;
11788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11789 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11790 return SWIG_Py_Void();
11791 }
11792
11793 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 return SWIG_Python_InitShadowInstance(args);
11795 }
11796
11797 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 PyObject *resultobj = 0;
11799 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11800 wxString result;
11801 void *argp1 = 0 ;
11802 int res1 = 0 ;
11803 PyObject *swig_obj[1] ;
11804
11805 if (!args) SWIG_fail;
11806 swig_obj[0] = args;
11807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11808 if (!SWIG_IsOK(res1)) {
11809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11810 }
11811 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = (arg1)->GetName();
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 #if wxUSE_UNICODE
11820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11821 #else
11822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11823 #endif
11824 }
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11832 PyObject *resultobj = 0;
11833 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11834 wxString result;
11835 void *argp1 = 0 ;
11836 int res1 = 0 ;
11837 PyObject *swig_obj[1] ;
11838
11839 if (!args) SWIG_fail;
11840 swig_obj[0] = args;
11841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11842 if (!SWIG_IsOK(res1)) {
11843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11844 }
11845 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 result = (arg1)->GetExtension();
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 #if wxUSE_UNICODE
11854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11855 #else
11856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11857 #endif
11858 }
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11868 long result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11878 }
11879 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (long)(arg1)->GetType();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_From_long(static_cast< long >(result));
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11896 wxString result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11906 }
11907 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (arg1)->GetMimeType();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 #if wxUSE_UNICODE
11916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11917 #else
11918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11919 #endif
11920 }
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11928 PyObject *resultobj = 0;
11929 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11930 wxString *arg2 = 0 ;
11931 bool result;
11932 void *argp1 = 0 ;
11933 int res1 = 0 ;
11934 bool temp2 = false ;
11935 PyObject * obj0 = 0 ;
11936 PyObject * obj1 = 0 ;
11937 char * kwnames[] = {
11938 (char *) "self",(char *) "name", NULL
11939 };
11940
11941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11943 if (!SWIG_IsOK(res1)) {
11944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11945 }
11946 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11947 {
11948 arg2 = wxString_in_helper(obj1);
11949 if (arg2 == NULL) SWIG_fail;
11950 temp2 = true;
11951 }
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 {
11962 if (temp2)
11963 delete arg2;
11964 }
11965 return resultobj;
11966 fail:
11967 {
11968 if (temp2)
11969 delete arg2;
11970 }
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj = 0;
11977 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11978 wxInputStream *arg2 = 0 ;
11979 bool result;
11980 void *argp1 = 0 ;
11981 int res1 = 0 ;
11982 wxPyInputStream *temp2 ;
11983 bool created2 ;
11984 PyObject * obj0 = 0 ;
11985 PyObject * obj1 = 0 ;
11986 char * kwnames[] = {
11987 (char *) "self",(char *) "stream", NULL
11988 };
11989
11990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11994 }
11995 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11996 {
11997 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11998 arg2 = temp2->m_wxis;
11999 created2 = false;
12000 } else {
12001 PyErr_Clear(); // clear the failure of the wxPyConvert above
12002 arg2 = wxPyCBInputStream_create(obj1, false);
12003 if (arg2 == NULL) {
12004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12005 SWIG_fail;
12006 }
12007 created2 = true;
12008 }
12009 }
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 result = (bool)(arg1)->CanRead(*arg2);
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12018 }
12019 {
12020 if (created2) delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (created2) delete arg2;
12026 }
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj = 0;
12033 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12034 wxString *arg2 = 0 ;
12035 void *argp1 = 0 ;
12036 int res1 = 0 ;
12037 bool temp2 = false ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 char * kwnames[] = {
12041 (char *) "self",(char *) "name", NULL
12042 };
12043
12044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12046 if (!SWIG_IsOK(res1)) {
12047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12048 }
12049 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12050 {
12051 arg2 = wxString_in_helper(obj1);
12052 if (arg2 == NULL) SWIG_fail;
12053 temp2 = true;
12054 }
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 (arg1)->SetName((wxString const &)*arg2);
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_Py_Void();
12062 {
12063 if (temp2)
12064 delete arg2;
12065 }
12066 return resultobj;
12067 fail:
12068 {
12069 if (temp2)
12070 delete arg2;
12071 }
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj = 0;
12078 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12079 wxString *arg2 = 0 ;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 bool temp2 = false ;
12083 PyObject * obj0 = 0 ;
12084 PyObject * obj1 = 0 ;
12085 char * kwnames[] = {
12086 (char *) "self",(char *) "extension", NULL
12087 };
12088
12089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12091 if (!SWIG_IsOK(res1)) {
12092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12093 }
12094 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12095 {
12096 arg2 = wxString_in_helper(obj1);
12097 if (arg2 == NULL) SWIG_fail;
12098 temp2 = true;
12099 }
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 (arg1)->SetExtension((wxString const &)*arg2);
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 resultobj = SWIG_Py_Void();
12107 {
12108 if (temp2)
12109 delete arg2;
12110 }
12111 return resultobj;
12112 fail:
12113 {
12114 if (temp2)
12115 delete arg2;
12116 }
12117 return NULL;
12118 }
12119
12120
12121 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj = 0;
12123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12124 long arg2 ;
12125 void *argp1 = 0 ;
12126 int res1 = 0 ;
12127 long val2 ;
12128 int ecode2 = 0 ;
12129 PyObject * obj0 = 0 ;
12130 PyObject * obj1 = 0 ;
12131 char * kwnames[] = {
12132 (char *) "self",(char *) "type", NULL
12133 };
12134
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12137 if (!SWIG_IsOK(res1)) {
12138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12139 }
12140 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12141 ecode2 = SWIG_AsVal_long(obj1, &val2);
12142 if (!SWIG_IsOK(ecode2)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12144 }
12145 arg2 = static_cast< long >(val2);
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 (arg1)->SetType(arg2);
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 resultobj = SWIG_Py_Void();
12153 return resultobj;
12154 fail:
12155 return NULL;
12156 }
12157
12158
12159 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12160 PyObject *resultobj = 0;
12161 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12162 wxString *arg2 = 0 ;
12163 void *argp1 = 0 ;
12164 int res1 = 0 ;
12165 bool temp2 = false ;
12166 PyObject * obj0 = 0 ;
12167 PyObject * obj1 = 0 ;
12168 char * kwnames[] = {
12169 (char *) "self",(char *) "mimetype", NULL
12170 };
12171
12172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12174 if (!SWIG_IsOK(res1)) {
12175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12176 }
12177 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12178 {
12179 arg2 = wxString_in_helper(obj1);
12180 if (arg2 == NULL) SWIG_fail;
12181 temp2 = true;
12182 }
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 (arg1)->SetMimeType((wxString const &)*arg2);
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 resultobj = SWIG_Py_Void();
12190 {
12191 if (temp2)
12192 delete arg2;
12193 }
12194 return resultobj;
12195 fail:
12196 {
12197 if (temp2)
12198 delete arg2;
12199 }
12200 return NULL;
12201 }
12202
12203
12204 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12205 PyObject *obj;
12206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12207 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12208 return SWIG_Py_Void();
12209 }
12210
12211 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12212 PyObject *resultobj = 0;
12213 wxPyImageHandler *result = 0 ;
12214
12215 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (wxPyImageHandler *)new wxPyImageHandler();
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = 0;
12231 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12232 PyObject *arg2 = (PyObject *) 0 ;
12233 void *argp1 = 0 ;
12234 int res1 = 0 ;
12235 PyObject * obj0 = 0 ;
12236 PyObject * obj1 = 0 ;
12237 char * kwnames[] = {
12238 (char *) "self",(char *) "self", NULL
12239 };
12240
12241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12243 if (!SWIG_IsOK(res1)) {
12244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12245 }
12246 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12247 arg2 = obj1;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 (arg1)->_SetSelf(arg2);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 resultobj = SWIG_Py_Void();
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12262 PyObject *obj;
12263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12264 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12265 return SWIG_Py_Void();
12266 }
12267
12268 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 return SWIG_Python_InitShadowInstance(args);
12270 }
12271
12272 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12273 PyObject *resultobj = 0;
12274 wxImageHistogram *result = 0 ;
12275
12276 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (wxImageHistogram *)new wxImageHistogram();
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj = 0;
12292 byte arg1 ;
12293 byte arg2 ;
12294 byte arg3 ;
12295 unsigned long result;
12296 unsigned char val1 ;
12297 int ecode1 = 0 ;
12298 unsigned char val2 ;
12299 int ecode2 = 0 ;
12300 unsigned char val3 ;
12301 int ecode3 = 0 ;
12302 PyObject * obj0 = 0 ;
12303 PyObject * obj1 = 0 ;
12304 PyObject * obj2 = 0 ;
12305 char * kwnames[] = {
12306 (char *) "r",(char *) "g",(char *) "b", NULL
12307 };
12308
12309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12310 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12311 if (!SWIG_IsOK(ecode1)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12313 }
12314 arg1 = static_cast< byte >(val1);
12315 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12316 if (!SWIG_IsOK(ecode2)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12318 }
12319 arg2 = static_cast< byte >(val2);
12320 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12321 if (!SWIG_IsOK(ecode3)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12323 }
12324 arg3 = static_cast< byte >(val3);
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12339 PyObject *resultobj = 0;
12340 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12341 byte *arg2 = (byte *) 0 ;
12342 byte *arg3 = (byte *) 0 ;
12343 byte *arg4 = (byte *) 0 ;
12344 byte arg5 = (byte) 1 ;
12345 byte arg6 = (byte) 0 ;
12346 byte arg7 = (byte) 0 ;
12347 bool result;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 byte temp2 ;
12351 int res2 = SWIG_TMPOBJ ;
12352 byte temp3 ;
12353 int res3 = SWIG_TMPOBJ ;
12354 byte temp4 ;
12355 int res4 = SWIG_TMPOBJ ;
12356 unsigned char val5 ;
12357 int ecode5 = 0 ;
12358 unsigned char val6 ;
12359 int ecode6 = 0 ;
12360 unsigned char val7 ;
12361 int ecode7 = 0 ;
12362 PyObject * obj0 = 0 ;
12363 PyObject * obj1 = 0 ;
12364 PyObject * obj2 = 0 ;
12365 PyObject * obj3 = 0 ;
12366 char * kwnames[] = {
12367 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12368 };
12369
12370 arg2 = &temp2;
12371 arg3 = &temp3;
12372 arg4 = &temp4;
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 if (obj1) {
12380 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12381 if (!SWIG_IsOK(ecode5)) {
12382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12383 }
12384 arg5 = static_cast< byte >(val5);
12385 }
12386 if (obj2) {
12387 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12388 if (!SWIG_IsOK(ecode6)) {
12389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12390 }
12391 arg6 = static_cast< byte >(val6);
12392 }
12393 if (obj3) {
12394 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12395 if (!SWIG_IsOK(ecode7)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12397 }
12398 arg7 = static_cast< byte >(val7);
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 {
12407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12408 }
12409 if (SWIG_IsTmpObj(res2)) {
12410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12411 } else {
12412 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12414 }
12415 if (SWIG_IsTmpObj(res3)) {
12416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12417 } else {
12418 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12420 }
12421 if (SWIG_IsTmpObj(res4)) {
12422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12423 } else {
12424 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12436 unsigned long arg2 ;
12437 unsigned long result;
12438 void *argp1 = 0 ;
12439 int res1 = 0 ;
12440 unsigned long val2 ;
12441 int ecode2 = 0 ;
12442 PyObject * obj0 = 0 ;
12443 PyObject * obj1 = 0 ;
12444 char * kwnames[] = {
12445 (char *) "self",(char *) "key", NULL
12446 };
12447
12448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12450 if (!SWIG_IsOK(res1)) {
12451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12452 }
12453 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12454 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12455 if (!SWIG_IsOK(ecode2)) {
12456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12457 }
12458 arg2 = static_cast< unsigned long >(val2);
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = 0;
12474 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12475 byte arg2 ;
12476 byte arg3 ;
12477 byte arg4 ;
12478 unsigned long result;
12479 void *argp1 = 0 ;
12480 int res1 = 0 ;
12481 unsigned char val2 ;
12482 int ecode2 = 0 ;
12483 unsigned char val3 ;
12484 int ecode3 = 0 ;
12485 unsigned char val4 ;
12486 int ecode4 = 0 ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 PyObject * obj2 = 0 ;
12490 PyObject * obj3 = 0 ;
12491 char * kwnames[] = {
12492 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12493 };
12494
12495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12497 if (!SWIG_IsOK(res1)) {
12498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12499 }
12500 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12501 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12502 if (!SWIG_IsOK(ecode2)) {
12503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12504 }
12505 arg2 = static_cast< byte >(val2);
12506 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12507 if (!SWIG_IsOK(ecode3)) {
12508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12509 }
12510 arg3 = static_cast< byte >(val3);
12511 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12512 if (!SWIG_IsOK(ecode4)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12514 }
12515 arg4 = static_cast< byte >(val4);
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12532 wxColour *arg2 = 0 ;
12533 unsigned long result;
12534 void *argp1 = 0 ;
12535 int res1 = 0 ;
12536 wxColour temp2 ;
12537 PyObject * obj0 = 0 ;
12538 PyObject * obj1 = 0 ;
12539 char * kwnames[] = {
12540 (char *) "self",(char *) "colour", NULL
12541 };
12542
12543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12545 if (!SWIG_IsOK(res1)) {
12546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12547 }
12548 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12549 {
12550 arg2 = &temp2;
12551 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12552 }
12553 {
12554 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12556 wxPyEndAllowThreads(__tstate);
12557 if (PyErr_Occurred()) SWIG_fail;
12558 }
12559 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567 PyObject *obj;
12568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12569 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12570 return SWIG_Py_Void();
12571 }
12572
12573 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 return SWIG_Python_InitShadowInstance(args);
12575 }
12576
12577 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj = 0;
12579 byte arg1 = (byte) 0 ;
12580 byte arg2 = (byte) 0 ;
12581 byte arg3 = (byte) 0 ;
12582 wxImage_RGBValue *result = 0 ;
12583 unsigned char val1 ;
12584 int ecode1 = 0 ;
12585 unsigned char val2 ;
12586 int ecode2 = 0 ;
12587 unsigned char val3 ;
12588 int ecode3 = 0 ;
12589 PyObject * obj0 = 0 ;
12590 PyObject * obj1 = 0 ;
12591 PyObject * obj2 = 0 ;
12592 char * kwnames[] = {
12593 (char *) "r",(char *) "g",(char *) "b", NULL
12594 };
12595
12596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12597 if (obj0) {
12598 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12599 if (!SWIG_IsOK(ecode1)) {
12600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12601 }
12602 arg1 = static_cast< byte >(val1);
12603 }
12604 if (obj1) {
12605 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12606 if (!SWIG_IsOK(ecode2)) {
12607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12608 }
12609 arg2 = static_cast< byte >(val2);
12610 }
12611 if (obj2) {
12612 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12613 if (!SWIG_IsOK(ecode3)) {
12614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12615 }
12616 arg3 = static_cast< byte >(val3);
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 PyObject *resultobj = 0;
12633 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12634 byte arg2 ;
12635 void *argp1 = 0 ;
12636 int res1 = 0 ;
12637 unsigned char val2 ;
12638 int ecode2 = 0 ;
12639 PyObject *swig_obj[2] ;
12640
12641 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12643 if (!SWIG_IsOK(res1)) {
12644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12645 }
12646 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12647 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12648 if (!SWIG_IsOK(ecode2)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12650 }
12651 arg2 = static_cast< byte >(val2);
12652 if (arg1) (arg1)->red = arg2;
12653
12654 resultobj = SWIG_Py_Void();
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12664 byte result;
12665 void *argp1 = 0 ;
12666 int res1 = 0 ;
12667 PyObject *swig_obj[1] ;
12668
12669 if (!args) SWIG_fail;
12670 swig_obj[0] = args;
12671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12672 if (!SWIG_IsOK(res1)) {
12673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12674 }
12675 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12676 result = (byte) ((arg1)->red);
12677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12687 byte arg2 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 unsigned char val2 ;
12691 int ecode2 = 0 ;
12692 PyObject *swig_obj[2] ;
12693
12694 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12698 }
12699 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12700 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12701 if (!SWIG_IsOK(ecode2)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12703 }
12704 arg2 = static_cast< byte >(val2);
12705 if (arg1) (arg1)->green = arg2;
12706
12707 resultobj = SWIG_Py_Void();
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12715 PyObject *resultobj = 0;
12716 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12717 byte result;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 PyObject *swig_obj[1] ;
12721
12722 if (!args) SWIG_fail;
12723 swig_obj[0] = args;
12724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12725 if (!SWIG_IsOK(res1)) {
12726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12727 }
12728 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12729 result = (byte) ((arg1)->green);
12730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 PyObject *resultobj = 0;
12739 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12740 byte arg2 ;
12741 void *argp1 = 0 ;
12742 int res1 = 0 ;
12743 unsigned char val2 ;
12744 int ecode2 = 0 ;
12745 PyObject *swig_obj[2] ;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12749 if (!SWIG_IsOK(res1)) {
12750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12751 }
12752 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12753 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12754 if (!SWIG_IsOK(ecode2)) {
12755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12756 }
12757 arg2 = static_cast< byte >(val2);
12758 if (arg1) (arg1)->blue = arg2;
12759
12760 resultobj = SWIG_Py_Void();
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12768 PyObject *resultobj = 0;
12769 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12770 byte result;
12771 void *argp1 = 0 ;
12772 int res1 = 0 ;
12773 PyObject *swig_obj[1] ;
12774
12775 if (!args) SWIG_fail;
12776 swig_obj[0] = args;
12777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12778 if (!SWIG_IsOK(res1)) {
12779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12780 }
12781 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12782 result = (byte) ((arg1)->blue);
12783 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *obj;
12792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12793 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12794 return SWIG_Py_Void();
12795 }
12796
12797 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 return SWIG_Python_InitShadowInstance(args);
12799 }
12800
12801 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12802 PyObject *resultobj = 0;
12803 double arg1 = (double) 0.0 ;
12804 double arg2 = (double) 0.0 ;
12805 double arg3 = (double) 0.0 ;
12806 wxImage_HSVValue *result = 0 ;
12807 double val1 ;
12808 int ecode1 = 0 ;
12809 double val2 ;
12810 int ecode2 = 0 ;
12811 double val3 ;
12812 int ecode3 = 0 ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 PyObject * obj2 = 0 ;
12816 char * kwnames[] = {
12817 (char *) "h",(char *) "s",(char *) "v", NULL
12818 };
12819
12820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12821 if (obj0) {
12822 ecode1 = SWIG_AsVal_double(obj0, &val1);
12823 if (!SWIG_IsOK(ecode1)) {
12824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12825 }
12826 arg1 = static_cast< double >(val1);
12827 }
12828 if (obj1) {
12829 ecode2 = SWIG_AsVal_double(obj1, &val2);
12830 if (!SWIG_IsOK(ecode2)) {
12831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12832 }
12833 arg2 = static_cast< double >(val2);
12834 }
12835 if (obj2) {
12836 ecode3 = SWIG_AsVal_double(obj2, &val3);
12837 if (!SWIG_IsOK(ecode3)) {
12838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12839 }
12840 arg3 = static_cast< double >(val3);
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 PyObject *resultobj = 0;
12857 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12858 double arg2 ;
12859 void *argp1 = 0 ;
12860 int res1 = 0 ;
12861 double val2 ;
12862 int ecode2 = 0 ;
12863 PyObject *swig_obj[2] ;
12864
12865 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12867 if (!SWIG_IsOK(res1)) {
12868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12869 }
12870 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12871 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12874 }
12875 arg2 = static_cast< double >(val2);
12876 if (arg1) (arg1)->hue = arg2;
12877
12878 resultobj = SWIG_Py_Void();
12879 return resultobj;
12880 fail:
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12886 PyObject *resultobj = 0;
12887 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12888 double result;
12889 void *argp1 = 0 ;
12890 int res1 = 0 ;
12891 PyObject *swig_obj[1] ;
12892
12893 if (!args) SWIG_fail;
12894 swig_obj[0] = args;
12895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12896 if (!SWIG_IsOK(res1)) {
12897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12898 }
12899 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12900 result = (double) ((arg1)->hue);
12901 resultobj = SWIG_From_double(static_cast< double >(result));
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *resultobj = 0;
12910 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12911 double arg2 ;
12912 void *argp1 = 0 ;
12913 int res1 = 0 ;
12914 double val2 ;
12915 int ecode2 = 0 ;
12916 PyObject *swig_obj[2] ;
12917
12918 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12922 }
12923 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12924 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12925 if (!SWIG_IsOK(ecode2)) {
12926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12927 }
12928 arg2 = static_cast< double >(val2);
12929 if (arg1) (arg1)->saturation = arg2;
12930
12931 resultobj = SWIG_Py_Void();
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12941 double result;
12942 void *argp1 = 0 ;
12943 int res1 = 0 ;
12944 PyObject *swig_obj[1] ;
12945
12946 if (!args) SWIG_fail;
12947 swig_obj[0] = args;
12948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12951 }
12952 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12953 result = (double) ((arg1)->saturation);
12954 resultobj = SWIG_From_double(static_cast< double >(result));
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 PyObject *resultobj = 0;
12963 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12964 double arg2 ;
12965 void *argp1 = 0 ;
12966 int res1 = 0 ;
12967 double val2 ;
12968 int ecode2 = 0 ;
12969 PyObject *swig_obj[2] ;
12970
12971 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12973 if (!SWIG_IsOK(res1)) {
12974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12975 }
12976 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12977 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12978 if (!SWIG_IsOK(ecode2)) {
12979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12980 }
12981 arg2 = static_cast< double >(val2);
12982 if (arg1) (arg1)->value = arg2;
12983
12984 resultobj = SWIG_Py_Void();
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12992 PyObject *resultobj = 0;
12993 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12994 double result;
12995 void *argp1 = 0 ;
12996 int res1 = 0 ;
12997 PyObject *swig_obj[1] ;
12998
12999 if (!args) SWIG_fail;
13000 swig_obj[0] = args;
13001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13002 if (!SWIG_IsOK(res1)) {
13003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13004 }
13005 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13006 result = (double) ((arg1)->value);
13007 resultobj = SWIG_From_double(static_cast< double >(result));
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *obj;
13016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13017 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13018 return SWIG_Py_Void();
13019 }
13020
13021 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13022 return SWIG_Python_InitShadowInstance(args);
13023 }
13024
13025 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13026 PyObject *resultobj = 0;
13027 wxString *arg1 = 0 ;
13028 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13029 int arg3 = (int) -1 ;
13030 wxImage *result = 0 ;
13031 bool temp1 = false ;
13032 long val2 ;
13033 int ecode2 = 0 ;
13034 int val3 ;
13035 int ecode3 = 0 ;
13036 PyObject * obj0 = 0 ;
13037 PyObject * obj1 = 0 ;
13038 PyObject * obj2 = 0 ;
13039 char * kwnames[] = {
13040 (char *) "name",(char *) "type",(char *) "index", NULL
13041 };
13042
13043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13044 {
13045 arg1 = wxString_in_helper(obj0);
13046 if (arg1 == NULL) SWIG_fail;
13047 temp1 = true;
13048 }
13049 if (obj1) {
13050 ecode2 = SWIG_AsVal_long(obj1, &val2);
13051 if (!SWIG_IsOK(ecode2)) {
13052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13053 }
13054 arg2 = static_cast< long >(val2);
13055 }
13056 if (obj2) {
13057 ecode3 = SWIG_AsVal_int(obj2, &val3);
13058 if (!SWIG_IsOK(ecode3)) {
13059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13060 }
13061 arg3 = static_cast< int >(val3);
13062 }
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13070 {
13071 if (temp1)
13072 delete arg1;
13073 }
13074 return resultobj;
13075 fail:
13076 {
13077 if (temp1)
13078 delete arg1;
13079 }
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *resultobj = 0;
13086 wxImage *arg1 = (wxImage *) 0 ;
13087 void *argp1 = 0 ;
13088 int res1 = 0 ;
13089 PyObject *swig_obj[1] ;
13090
13091 if (!args) SWIG_fail;
13092 swig_obj[0] = args;
13093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13096 }
13097 arg1 = reinterpret_cast< wxImage * >(argp1);
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 delete arg1;
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_Py_Void();
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj = 0;
13114 wxString *arg1 = 0 ;
13115 wxString *arg2 = 0 ;
13116 int arg3 = (int) -1 ;
13117 wxImage *result = 0 ;
13118 bool temp1 = false ;
13119 bool temp2 = false ;
13120 int val3 ;
13121 int ecode3 = 0 ;
13122 PyObject * obj0 = 0 ;
13123 PyObject * obj1 = 0 ;
13124 PyObject * obj2 = 0 ;
13125 char * kwnames[] = {
13126 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13127 };
13128
13129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13130 {
13131 arg1 = wxString_in_helper(obj0);
13132 if (arg1 == NULL) SWIG_fail;
13133 temp1 = true;
13134 }
13135 {
13136 arg2 = wxString_in_helper(obj1);
13137 if (arg2 == NULL) SWIG_fail;
13138 temp2 = true;
13139 }
13140 if (obj2) {
13141 ecode3 = SWIG_AsVal_int(obj2, &val3);
13142 if (!SWIG_IsOK(ecode3)) {
13143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13144 }
13145 arg3 = static_cast< int >(val3);
13146 }
13147 {
13148 PyThreadState* __tstate = wxPyBeginAllowThreads();
13149 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13150 wxPyEndAllowThreads(__tstate);
13151 if (PyErr_Occurred()) SWIG_fail;
13152 }
13153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13154 {
13155 if (temp1)
13156 delete arg1;
13157 }
13158 {
13159 if (temp2)
13160 delete arg2;
13161 }
13162 return resultobj;
13163 fail:
13164 {
13165 if (temp1)
13166 delete arg1;
13167 }
13168 {
13169 if (temp2)
13170 delete arg2;
13171 }
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = 0;
13178 wxInputStream *arg1 = 0 ;
13179 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13180 int arg3 = (int) -1 ;
13181 wxImage *result = 0 ;
13182 wxPyInputStream *temp1 ;
13183 bool created1 ;
13184 long val2 ;
13185 int ecode2 = 0 ;
13186 int val3 ;
13187 int ecode3 = 0 ;
13188 PyObject * obj0 = 0 ;
13189 PyObject * obj1 = 0 ;
13190 PyObject * obj2 = 0 ;
13191 char * kwnames[] = {
13192 (char *) "stream",(char *) "type",(char *) "index", NULL
13193 };
13194
13195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13196 {
13197 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13198 arg1 = temp1->m_wxis;
13199 created1 = false;
13200 } else {
13201 PyErr_Clear(); // clear the failure of the wxPyConvert above
13202 arg1 = wxPyCBInputStream_create(obj0, false);
13203 if (arg1 == NULL) {
13204 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13205 SWIG_fail;
13206 }
13207 created1 = true;
13208 }
13209 }
13210 if (obj1) {
13211 ecode2 = SWIG_AsVal_long(obj1, &val2);
13212 if (!SWIG_IsOK(ecode2)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13214 }
13215 arg2 = static_cast< long >(val2);
13216 }
13217 if (obj2) {
13218 ecode3 = SWIG_AsVal_int(obj2, &val3);
13219 if (!SWIG_IsOK(ecode3)) {
13220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13221 }
13222 arg3 = static_cast< int >(val3);
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13231 {
13232 if (created1) delete arg1;
13233 }
13234 return resultobj;
13235 fail:
13236 {
13237 if (created1) delete arg1;
13238 }
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj = 0;
13245 wxInputStream *arg1 = 0 ;
13246 wxString *arg2 = 0 ;
13247 int arg3 = (int) -1 ;
13248 wxImage *result = 0 ;
13249 wxPyInputStream *temp1 ;
13250 bool created1 ;
13251 bool temp2 = false ;
13252 int val3 ;
13253 int ecode3 = 0 ;
13254 PyObject * obj0 = 0 ;
13255 PyObject * obj1 = 0 ;
13256 PyObject * obj2 = 0 ;
13257 char * kwnames[] = {
13258 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13259 };
13260
13261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13262 {
13263 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13264 arg1 = temp1->m_wxis;
13265 created1 = false;
13266 } else {
13267 PyErr_Clear(); // clear the failure of the wxPyConvert above
13268 arg1 = wxPyCBInputStream_create(obj0, false);
13269 if (arg1 == NULL) {
13270 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13271 SWIG_fail;
13272 }
13273 created1 = true;
13274 }
13275 }
13276 {
13277 arg2 = wxString_in_helper(obj1);
13278 if (arg2 == NULL) SWIG_fail;
13279 temp2 = true;
13280 }
13281 if (obj2) {
13282 ecode3 = SWIG_AsVal_int(obj2, &val3);
13283 if (!SWIG_IsOK(ecode3)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13285 }
13286 arg3 = static_cast< int >(val3);
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13295 {
13296 if (created1) delete arg1;
13297 }
13298 {
13299 if (temp2)
13300 delete arg2;
13301 }
13302 return resultobj;
13303 fail:
13304 {
13305 if (created1) delete arg1;
13306 }
13307 {
13308 if (temp2)
13309 delete arg2;
13310 }
13311 return NULL;
13312 }
13313
13314
13315 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13316 PyObject *resultobj = 0;
13317 int arg1 = (int) 0 ;
13318 int arg2 = (int) 0 ;
13319 bool arg3 = (bool) true ;
13320 wxImage *result = 0 ;
13321 int val1 ;
13322 int ecode1 = 0 ;
13323 int val2 ;
13324 int ecode2 = 0 ;
13325 bool val3 ;
13326 int ecode3 = 0 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 char * kwnames[] = {
13331 (char *) "width",(char *) "height",(char *) "clear", NULL
13332 };
13333
13334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13335 if (obj0) {
13336 ecode1 = SWIG_AsVal_int(obj0, &val1);
13337 if (!SWIG_IsOK(ecode1)) {
13338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13339 }
13340 arg1 = static_cast< int >(val1);
13341 }
13342 if (obj1) {
13343 ecode2 = SWIG_AsVal_int(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13346 }
13347 arg2 = static_cast< int >(val2);
13348 }
13349 if (obj2) {
13350 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13353 }
13354 arg3 = static_cast< bool >(val3);
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj = 0;
13371 wxBitmap *arg1 = 0 ;
13372 wxImage *result = 0 ;
13373 void *argp1 = 0 ;
13374 int res1 = 0 ;
13375 PyObject * obj0 = 0 ;
13376 char * kwnames[] = {
13377 (char *) "bitmap", NULL
13378 };
13379
13380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13381 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13382 if (!SWIG_IsOK(res1)) {
13383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13384 }
13385 if (!argp1) {
13386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13387 }
13388 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13389 {
13390 if (!wxPyCheckForApp()) SWIG_fail;
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj = 0;
13405 int arg1 ;
13406 int arg2 ;
13407 buffer arg3 ;
13408 int arg4 ;
13409 wxImage *result = 0 ;
13410 int val1 ;
13411 int ecode1 = 0 ;
13412 int val2 ;
13413 int ecode2 = 0 ;
13414 PyObject * obj0 = 0 ;
13415 PyObject * obj1 = 0 ;
13416 PyObject * obj2 = 0 ;
13417 char * kwnames[] = {
13418 (char *) "width",(char *) "height",(char *) "data", NULL
13419 };
13420
13421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13422 ecode1 = SWIG_AsVal_int(obj0, &val1);
13423 if (!SWIG_IsOK(ecode1)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13425 }
13426 arg1 = static_cast< int >(val1);
13427 ecode2 = SWIG_AsVal_int(obj1, &val2);
13428 if (!SWIG_IsOK(ecode2)) {
13429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13430 }
13431 arg2 = static_cast< int >(val2);
13432 {
13433 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
13434 }
13435 {
13436 PyThreadState* __tstate = wxPyBeginAllowThreads();
13437 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13438 wxPyEndAllowThreads(__tstate);
13439 if (PyErr_Occurred()) SWIG_fail;
13440 }
13441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13442 return resultobj;
13443 fail:
13444 return NULL;
13445 }
13446
13447
13448 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13449 PyObject *resultobj = 0;
13450 int arg1 ;
13451 int arg2 ;
13452 buffer arg3 ;
13453 int arg4 ;
13454 buffer arg5 ;
13455 int arg6 ;
13456 wxImage *result = 0 ;
13457 int val1 ;
13458 int ecode1 = 0 ;
13459 int val2 ;
13460 int ecode2 = 0 ;
13461 PyObject * obj0 = 0 ;
13462 PyObject * obj1 = 0 ;
13463 PyObject * obj2 = 0 ;
13464 PyObject * obj3 = 0 ;
13465 char * kwnames[] = {
13466 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13467 };
13468
13469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13470 ecode1 = SWIG_AsVal_int(obj0, &val1);
13471 if (!SWIG_IsOK(ecode1)) {
13472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13473 }
13474 arg1 = static_cast< int >(val1);
13475 ecode2 = SWIG_AsVal_int(obj1, &val2);
13476 if (!SWIG_IsOK(ecode2)) {
13477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13478 }
13479 arg2 = static_cast< int >(val2);
13480 {
13481 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
13482 }
13483 {
13484 if (obj3 != Py_None) {
13485 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &arg6) == -1) SWIG_fail;
13486 }
13487 }
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13502 PyObject *resultobj = 0;
13503 wxImage *arg1 = (wxImage *) 0 ;
13504 int arg2 ;
13505 int arg3 ;
13506 bool arg4 = (bool) true ;
13507 void *argp1 = 0 ;
13508 int res1 = 0 ;
13509 int val2 ;
13510 int ecode2 = 0 ;
13511 int val3 ;
13512 int ecode3 = 0 ;
13513 bool val4 ;
13514 int ecode4 = 0 ;
13515 PyObject * obj0 = 0 ;
13516 PyObject * obj1 = 0 ;
13517 PyObject * obj2 = 0 ;
13518 PyObject * obj3 = 0 ;
13519 char * kwnames[] = {
13520 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13521 };
13522
13523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13525 if (!SWIG_IsOK(res1)) {
13526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13527 }
13528 arg1 = reinterpret_cast< wxImage * >(argp1);
13529 ecode2 = SWIG_AsVal_int(obj1, &val2);
13530 if (!SWIG_IsOK(ecode2)) {
13531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13532 }
13533 arg2 = static_cast< int >(val2);
13534 ecode3 = SWIG_AsVal_int(obj2, &val3);
13535 if (!SWIG_IsOK(ecode3)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13537 }
13538 arg3 = static_cast< int >(val3);
13539 if (obj3) {
13540 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13541 if (!SWIG_IsOK(ecode4)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13543 }
13544 arg4 = static_cast< bool >(val4);
13545 }
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 (arg1)->Create(arg2,arg3,arg4);
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_Py_Void();
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13560 PyObject *resultobj = 0;
13561 wxImage *arg1 = (wxImage *) 0 ;
13562 void *argp1 = 0 ;
13563 int res1 = 0 ;
13564 PyObject *swig_obj[1] ;
13565
13566 if (!args) SWIG_fail;
13567 swig_obj[0] = args;
13568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13569 if (!SWIG_IsOK(res1)) {
13570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13571 }
13572 arg1 = reinterpret_cast< wxImage * >(argp1);
13573 {
13574 PyThreadState* __tstate = wxPyBeginAllowThreads();
13575 (arg1)->Destroy();
13576 wxPyEndAllowThreads(__tstate);
13577 if (PyErr_Occurred()) SWIG_fail;
13578 }
13579 resultobj = SWIG_Py_Void();
13580 return resultobj;
13581 fail:
13582 return NULL;
13583 }
13584
13585
13586 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13587 PyObject *resultobj = 0;
13588 wxImage *arg1 = (wxImage *) 0 ;
13589 int arg2 ;
13590 int arg3 ;
13591 SwigValueWrapper<wxImage > result;
13592 void *argp1 = 0 ;
13593 int res1 = 0 ;
13594 int val2 ;
13595 int ecode2 = 0 ;
13596 int val3 ;
13597 int ecode3 = 0 ;
13598 PyObject * obj0 = 0 ;
13599 PyObject * obj1 = 0 ;
13600 PyObject * obj2 = 0 ;
13601 char * kwnames[] = {
13602 (char *) "self",(char *) "width",(char *) "height", NULL
13603 };
13604
13605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13607 if (!SWIG_IsOK(res1)) {
13608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13609 }
13610 arg1 = reinterpret_cast< wxImage * >(argp1);
13611 ecode2 = SWIG_AsVal_int(obj1, &val2);
13612 if (!SWIG_IsOK(ecode2)) {
13613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13614 }
13615 arg2 = static_cast< int >(val2);
13616 ecode3 = SWIG_AsVal_int(obj2, &val3);
13617 if (!SWIG_IsOK(ecode3)) {
13618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13619 }
13620 arg3 = static_cast< int >(val3);
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 result = (arg1)->Scale(arg2,arg3);
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj = 0;
13636 wxImage *arg1 = (wxImage *) 0 ;
13637 int arg2 ;
13638 int arg3 ;
13639 SwigValueWrapper<wxImage > result;
13640 void *argp1 = 0 ;
13641 int res1 = 0 ;
13642 int val2 ;
13643 int ecode2 = 0 ;
13644 int val3 ;
13645 int ecode3 = 0 ;
13646 PyObject * obj0 = 0 ;
13647 PyObject * obj1 = 0 ;
13648 PyObject * obj2 = 0 ;
13649 char * kwnames[] = {
13650 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13651 };
13652
13653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) 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_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13657 }
13658 arg1 = reinterpret_cast< wxImage * >(argp1);
13659 ecode2 = SWIG_AsVal_int(obj1, &val2);
13660 if (!SWIG_IsOK(ecode2)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13662 }
13663 arg2 = static_cast< int >(val2);
13664 ecode3 = SWIG_AsVal_int(obj2, &val3);
13665 if (!SWIG_IsOK(ecode3)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13667 }
13668 arg3 = static_cast< int >(val3);
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxImage *arg1 = (wxImage *) 0 ;
13685 int arg2 ;
13686 int arg3 ;
13687 wxImage *result = 0 ;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 int val3 ;
13693 int ecode3 = 0 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "width",(char *) "height", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 ecode3 = SWIG_AsVal_int(obj2, &val3);
13713 if (!SWIG_IsOK(ecode3)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13715 }
13716 arg3 = static_cast< int >(val3);
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 {
13720 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13721 result = (wxImage *) &_result_ref;
13722 }
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = 0;
13735 wxImage *arg1 = (wxImage *) 0 ;
13736 wxSize *arg2 = 0 ;
13737 wxPoint *arg3 = 0 ;
13738 int arg4 = (int) -1 ;
13739 int arg5 = (int) -1 ;
13740 int arg6 = (int) -1 ;
13741 wxImage *result = 0 ;
13742 void *argp1 = 0 ;
13743 int res1 = 0 ;
13744 wxSize temp2 ;
13745 wxPoint temp3 ;
13746 int val4 ;
13747 int ecode4 = 0 ;
13748 int val5 ;
13749 int ecode5 = 0 ;
13750 int val6 ;
13751 int ecode6 = 0 ;
13752 PyObject * obj0 = 0 ;
13753 PyObject * obj1 = 0 ;
13754 PyObject * obj2 = 0 ;
13755 PyObject * obj3 = 0 ;
13756 PyObject * obj4 = 0 ;
13757 PyObject * obj5 = 0 ;
13758 char * kwnames[] = {
13759 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13760 };
13761
13762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13764 if (!SWIG_IsOK(res1)) {
13765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13766 }
13767 arg1 = reinterpret_cast< wxImage * >(argp1);
13768 {
13769 arg2 = &temp2;
13770 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13771 }
13772 {
13773 arg3 = &temp3;
13774 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13775 }
13776 if (obj3) {
13777 ecode4 = SWIG_AsVal_int(obj3, &val4);
13778 if (!SWIG_IsOK(ecode4)) {
13779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13780 }
13781 arg4 = static_cast< int >(val4);
13782 }
13783 if (obj4) {
13784 ecode5 = SWIG_AsVal_int(obj4, &val5);
13785 if (!SWIG_IsOK(ecode5)) {
13786 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13787 }
13788 arg5 = static_cast< int >(val5);
13789 }
13790 if (obj5) {
13791 ecode6 = SWIG_AsVal_int(obj5, &val6);
13792 if (!SWIG_IsOK(ecode6)) {
13793 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13794 }
13795 arg6 = static_cast< int >(val6);
13796 }
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 {
13800 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13801 result = (wxImage *) &_result_ref;
13802 }
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13814 PyObject *resultobj = 0;
13815 wxImage *arg1 = (wxImage *) 0 ;
13816 int arg2 ;
13817 int arg3 ;
13818 byte arg4 ;
13819 byte arg5 ;
13820 byte arg6 ;
13821 void *argp1 = 0 ;
13822 int res1 = 0 ;
13823 int val2 ;
13824 int ecode2 = 0 ;
13825 int val3 ;
13826 int ecode3 = 0 ;
13827 unsigned char val4 ;
13828 int ecode4 = 0 ;
13829 unsigned char val5 ;
13830 int ecode5 = 0 ;
13831 unsigned char val6 ;
13832 int ecode6 = 0 ;
13833 PyObject * obj0 = 0 ;
13834 PyObject * obj1 = 0 ;
13835 PyObject * obj2 = 0 ;
13836 PyObject * obj3 = 0 ;
13837 PyObject * obj4 = 0 ;
13838 PyObject * obj5 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13845 if (!SWIG_IsOK(res1)) {
13846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13847 }
13848 arg1 = reinterpret_cast< wxImage * >(argp1);
13849 ecode2 = SWIG_AsVal_int(obj1, &val2);
13850 if (!SWIG_IsOK(ecode2)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13852 }
13853 arg2 = static_cast< int >(val2);
13854 ecode3 = SWIG_AsVal_int(obj2, &val3);
13855 if (!SWIG_IsOK(ecode3)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13857 }
13858 arg3 = static_cast< int >(val3);
13859 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13860 if (!SWIG_IsOK(ecode4)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13862 }
13863 arg4 = static_cast< byte >(val4);
13864 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13865 if (!SWIG_IsOK(ecode5)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13867 }
13868 arg5 = static_cast< byte >(val5);
13869 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13870 if (!SWIG_IsOK(ecode6)) {
13871 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13872 }
13873 arg6 = static_cast< byte >(val6);
13874 {
13875 PyThreadState* __tstate = wxPyBeginAllowThreads();
13876 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13877 wxPyEndAllowThreads(__tstate);
13878 if (PyErr_Occurred()) SWIG_fail;
13879 }
13880 resultobj = SWIG_Py_Void();
13881 return resultobj;
13882 fail:
13883 return NULL;
13884 }
13885
13886
13887 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj = 0;
13889 wxImage *arg1 = (wxImage *) 0 ;
13890 wxRect *arg2 = 0 ;
13891 byte arg3 ;
13892 byte arg4 ;
13893 byte arg5 ;
13894 void *argp1 = 0 ;
13895 int res1 = 0 ;
13896 wxRect temp2 ;
13897 unsigned char val3 ;
13898 int ecode3 = 0 ;
13899 unsigned char val4 ;
13900 int ecode4 = 0 ;
13901 unsigned char val5 ;
13902 int ecode5 = 0 ;
13903 PyObject * obj0 = 0 ;
13904 PyObject * obj1 = 0 ;
13905 PyObject * obj2 = 0 ;
13906 PyObject * obj3 = 0 ;
13907 PyObject * obj4 = 0 ;
13908 char * kwnames[] = {
13909 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13910 };
13911
13912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13914 if (!SWIG_IsOK(res1)) {
13915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13916 }
13917 arg1 = reinterpret_cast< wxImage * >(argp1);
13918 {
13919 arg2 = &temp2;
13920 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13921 }
13922 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13923 if (!SWIG_IsOK(ecode3)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13925 }
13926 arg3 = static_cast< byte >(val3);
13927 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13928 if (!SWIG_IsOK(ecode4)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13930 }
13931 arg4 = static_cast< byte >(val4);
13932 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13933 if (!SWIG_IsOK(ecode5)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13935 }
13936 arg5 = static_cast< byte >(val5);
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 resultobj = SWIG_Py_Void();
13944 return resultobj;
13945 fail:
13946 return NULL;
13947 }
13948
13949
13950 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13951 PyObject *resultobj = 0;
13952 wxImage *arg1 = (wxImage *) 0 ;
13953 int arg2 ;
13954 int arg3 ;
13955 byte result;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 int val2 ;
13959 int ecode2 = 0 ;
13960 int val3 ;
13961 int ecode3 = 0 ;
13962 PyObject * obj0 = 0 ;
13963 PyObject * obj1 = 0 ;
13964 PyObject * obj2 = 0 ;
13965 char * kwnames[] = {
13966 (char *) "self",(char *) "x",(char *) "y", NULL
13967 };
13968
13969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13971 if (!SWIG_IsOK(res1)) {
13972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13973 }
13974 arg1 = reinterpret_cast< wxImage * >(argp1);
13975 ecode2 = SWIG_AsVal_int(obj1, &val2);
13976 if (!SWIG_IsOK(ecode2)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13978 }
13979 arg2 = static_cast< int >(val2);
13980 ecode3 = SWIG_AsVal_int(obj2, &val3);
13981 if (!SWIG_IsOK(ecode3)) {
13982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13983 }
13984 arg3 = static_cast< int >(val3);
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 result = (byte)(arg1)->GetRed(arg2,arg3);
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13992 return resultobj;
13993 fail:
13994 return NULL;
13995 }
13996
13997
13998 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj = 0;
14000 wxImage *arg1 = (wxImage *) 0 ;
14001 int arg2 ;
14002 int arg3 ;
14003 byte result;
14004 void *argp1 = 0 ;
14005 int res1 = 0 ;
14006 int val2 ;
14007 int ecode2 = 0 ;
14008 int val3 ;
14009 int ecode3 = 0 ;
14010 PyObject * obj0 = 0 ;
14011 PyObject * obj1 = 0 ;
14012 PyObject * obj2 = 0 ;
14013 char * kwnames[] = {
14014 (char *) "self",(char *) "x",(char *) "y", NULL
14015 };
14016
14017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14019 if (!SWIG_IsOK(res1)) {
14020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14021 }
14022 arg1 = reinterpret_cast< wxImage * >(argp1);
14023 ecode2 = SWIG_AsVal_int(obj1, &val2);
14024 if (!SWIG_IsOK(ecode2)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14026 }
14027 arg2 = static_cast< int >(val2);
14028 ecode3 = SWIG_AsVal_int(obj2, &val3);
14029 if (!SWIG_IsOK(ecode3)) {
14030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14031 }
14032 arg3 = static_cast< int >(val3);
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = (byte)(arg1)->GetGreen(arg2,arg3);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14047 PyObject *resultobj = 0;
14048 wxImage *arg1 = (wxImage *) 0 ;
14049 int arg2 ;
14050 int arg3 ;
14051 byte result;
14052 void *argp1 = 0 ;
14053 int res1 = 0 ;
14054 int val2 ;
14055 int ecode2 = 0 ;
14056 int val3 ;
14057 int ecode3 = 0 ;
14058 PyObject * obj0 = 0 ;
14059 PyObject * obj1 = 0 ;
14060 PyObject * obj2 = 0 ;
14061 char * kwnames[] = {
14062 (char *) "self",(char *) "x",(char *) "y", NULL
14063 };
14064
14065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14067 if (!SWIG_IsOK(res1)) {
14068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14069 }
14070 arg1 = reinterpret_cast< wxImage * >(argp1);
14071 ecode2 = SWIG_AsVal_int(obj1, &val2);
14072 if (!SWIG_IsOK(ecode2)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14074 }
14075 arg2 = static_cast< int >(val2);
14076 ecode3 = SWIG_AsVal_int(obj2, &val3);
14077 if (!SWIG_IsOK(ecode3)) {
14078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14079 }
14080 arg3 = static_cast< int >(val3);
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 result = (byte)(arg1)->GetBlue(arg2,arg3);
14084 wxPyEndAllowThreads(__tstate);
14085 if (PyErr_Occurred()) SWIG_fail;
14086 }
14087 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj = 0;
14096 wxImage *arg1 = (wxImage *) 0 ;
14097 int arg2 ;
14098 int arg3 ;
14099 byte arg4 ;
14100 void *argp1 = 0 ;
14101 int res1 = 0 ;
14102 int val2 ;
14103 int ecode2 = 0 ;
14104 int val3 ;
14105 int ecode3 = 0 ;
14106 unsigned char val4 ;
14107 int ecode4 = 0 ;
14108 PyObject * obj0 = 0 ;
14109 PyObject * obj1 = 0 ;
14110 PyObject * obj2 = 0 ;
14111 PyObject * obj3 = 0 ;
14112 char * kwnames[] = {
14113 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14114 };
14115
14116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14118 if (!SWIG_IsOK(res1)) {
14119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14120 }
14121 arg1 = reinterpret_cast< wxImage * >(argp1);
14122 ecode2 = SWIG_AsVal_int(obj1, &val2);
14123 if (!SWIG_IsOK(ecode2)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14125 }
14126 arg2 = static_cast< int >(val2);
14127 ecode3 = SWIG_AsVal_int(obj2, &val3);
14128 if (!SWIG_IsOK(ecode3)) {
14129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14130 }
14131 arg3 = static_cast< int >(val3);
14132 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14133 if (!SWIG_IsOK(ecode4)) {
14134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14135 }
14136 arg4 = static_cast< byte >(val4);
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 (arg1)->SetAlpha(arg2,arg3,arg4);
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 resultobj = SWIG_Py_Void();
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxImage *arg1 = (wxImage *) 0 ;
14153 int arg2 ;
14154 int arg3 ;
14155 byte result;
14156 void *argp1 = 0 ;
14157 int res1 = 0 ;
14158 int val2 ;
14159 int ecode2 = 0 ;
14160 int val3 ;
14161 int ecode3 = 0 ;
14162 PyObject * obj0 = 0 ;
14163 PyObject * obj1 = 0 ;
14164 PyObject * obj2 = 0 ;
14165 char * kwnames[] = {
14166 (char *) "self",(char *) "x",(char *) "y", NULL
14167 };
14168
14169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) 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_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
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_GetAlpha" "', 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_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14183 }
14184 arg3 = static_cast< int >(val3);
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14199 PyObject *resultobj = 0;
14200 wxImage *arg1 = (wxImage *) 0 ;
14201 bool result;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 PyObject *swig_obj[1] ;
14205
14206 if (!args) SWIG_fail;
14207 swig_obj[0] = args;
14208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14209 if (!SWIG_IsOK(res1)) {
14210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14211 }
14212 arg1 = reinterpret_cast< wxImage * >(argp1);
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (bool)(arg1)->HasAlpha();
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 {
14220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14221 }
14222 return resultobj;
14223 fail:
14224 return NULL;
14225 }
14226
14227
14228 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14229 PyObject *resultobj = 0;
14230 wxImage *arg1 = (wxImage *) 0 ;
14231 void *argp1 = 0 ;
14232 int res1 = 0 ;
14233 PyObject *swig_obj[1] ;
14234
14235 if (!args) SWIG_fail;
14236 swig_obj[0] = args;
14237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14238 if (!SWIG_IsOK(res1)) {
14239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14240 }
14241 arg1 = reinterpret_cast< wxImage * >(argp1);
14242 {
14243 PyThreadState* __tstate = wxPyBeginAllowThreads();
14244 (arg1)->InitAlpha();
14245 wxPyEndAllowThreads(__tstate);
14246 if (PyErr_Occurred()) SWIG_fail;
14247 }
14248 resultobj = SWIG_Py_Void();
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj = 0;
14257 wxImage *arg1 = (wxImage *) 0 ;
14258 int arg2 ;
14259 int arg3 ;
14260 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14261 bool result;
14262 void *argp1 = 0 ;
14263 int res1 = 0 ;
14264 int val2 ;
14265 int ecode2 = 0 ;
14266 int val3 ;
14267 int ecode3 = 0 ;
14268 unsigned char val4 ;
14269 int ecode4 = 0 ;
14270 PyObject * obj0 = 0 ;
14271 PyObject * obj1 = 0 ;
14272 PyObject * obj2 = 0 ;
14273 PyObject * obj3 = 0 ;
14274 char * kwnames[] = {
14275 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14276 };
14277
14278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14280 if (!SWIG_IsOK(res1)) {
14281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14282 }
14283 arg1 = reinterpret_cast< wxImage * >(argp1);
14284 ecode2 = SWIG_AsVal_int(obj1, &val2);
14285 if (!SWIG_IsOK(ecode2)) {
14286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14287 }
14288 arg2 = static_cast< int >(val2);
14289 ecode3 = SWIG_AsVal_int(obj2, &val3);
14290 if (!SWIG_IsOK(ecode3)) {
14291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14292 }
14293 arg3 = static_cast< int >(val3);
14294 if (obj3) {
14295 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14296 if (!SWIG_IsOK(ecode4)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14298 }
14299 arg4 = static_cast< byte >(val4);
14300 }
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 {
14308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14309 }
14310 return resultobj;
14311 fail:
14312 return NULL;
14313 }
14314
14315
14316 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj = 0;
14318 wxImage *arg1 = (wxImage *) 0 ;
14319 byte *arg2 = (byte *) 0 ;
14320 byte *arg3 = (byte *) 0 ;
14321 byte *arg4 = (byte *) 0 ;
14322 byte arg5 = (byte) 0 ;
14323 byte arg6 = (byte) 0 ;
14324 byte arg7 = (byte) 0 ;
14325 bool result;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 byte temp2 ;
14329 int res2 = SWIG_TMPOBJ ;
14330 byte temp3 ;
14331 int res3 = SWIG_TMPOBJ ;
14332 byte temp4 ;
14333 int res4 = SWIG_TMPOBJ ;
14334 unsigned char val5 ;
14335 int ecode5 = 0 ;
14336 unsigned char val6 ;
14337 int ecode6 = 0 ;
14338 unsigned char val7 ;
14339 int ecode7 = 0 ;
14340 PyObject * obj0 = 0 ;
14341 PyObject * obj1 = 0 ;
14342 PyObject * obj2 = 0 ;
14343 PyObject * obj3 = 0 ;
14344 char * kwnames[] = {
14345 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14346 };
14347
14348 arg2 = &temp2;
14349 arg3 = &temp3;
14350 arg4 = &temp4;
14351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14353 if (!SWIG_IsOK(res1)) {
14354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14355 }
14356 arg1 = reinterpret_cast< wxImage * >(argp1);
14357 if (obj1) {
14358 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14359 if (!SWIG_IsOK(ecode5)) {
14360 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14361 }
14362 arg5 = static_cast< byte >(val5);
14363 }
14364 if (obj2) {
14365 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14366 if (!SWIG_IsOK(ecode6)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14368 }
14369 arg6 = static_cast< byte >(val6);
14370 }
14371 if (obj3) {
14372 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14373 if (!SWIG_IsOK(ecode7)) {
14374 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14375 }
14376 arg7 = static_cast< byte >(val7);
14377 }
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14386 }
14387 if (SWIG_IsTmpObj(res2)) {
14388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14389 } else {
14390 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14392 }
14393 if (SWIG_IsTmpObj(res3)) {
14394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14395 } else {
14396 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14398 }
14399 if (SWIG_IsTmpObj(res4)) {
14400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14401 } else {
14402 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14404 }
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14412 PyObject *resultobj = 0;
14413 wxImage *arg1 = (wxImage *) 0 ;
14414 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14415 bool result;
14416 void *argp1 = 0 ;
14417 int res1 = 0 ;
14418 unsigned char val2 ;
14419 int ecode2 = 0 ;
14420 PyObject * obj0 = 0 ;
14421 PyObject * obj1 = 0 ;
14422 char * kwnames[] = {
14423 (char *) "self",(char *) "threshold", NULL
14424 };
14425
14426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14428 if (!SWIG_IsOK(res1)) {
14429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14430 }
14431 arg1 = reinterpret_cast< wxImage * >(argp1);
14432 if (obj1) {
14433 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14434 if (!SWIG_IsOK(ecode2)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14436 }
14437 arg2 = static_cast< byte >(val2);
14438 }
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 {
14446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14447 }
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj = 0;
14456 wxImage *arg1 = (wxImage *) 0 ;
14457 byte arg2 ;
14458 byte arg3 ;
14459 byte arg4 ;
14460 bool result;
14461 void *argp1 = 0 ;
14462 int res1 = 0 ;
14463 unsigned char val2 ;
14464 int ecode2 = 0 ;
14465 unsigned char val3 ;
14466 int ecode3 = 0 ;
14467 unsigned char val4 ;
14468 int ecode4 = 0 ;
14469 PyObject * obj0 = 0 ;
14470 PyObject * obj1 = 0 ;
14471 PyObject * obj2 = 0 ;
14472 PyObject * obj3 = 0 ;
14473 char * kwnames[] = {
14474 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14475 };
14476
14477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14479 if (!SWIG_IsOK(res1)) {
14480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14481 }
14482 arg1 = reinterpret_cast< wxImage * >(argp1);
14483 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14484 if (!SWIG_IsOK(ecode2)) {
14485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14486 }
14487 arg2 = static_cast< byte >(val2);
14488 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14489 if (!SWIG_IsOK(ecode3)) {
14490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14491 }
14492 arg3 = static_cast< byte >(val3);
14493 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14494 if (!SWIG_IsOK(ecode4)) {
14495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14496 }
14497 arg4 = static_cast< byte >(val4);
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 {
14505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14506 }
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj = 0;
14515 wxImage *arg1 = (wxImage *) 0 ;
14516 wxImage *arg2 = 0 ;
14517 byte arg3 ;
14518 byte arg4 ;
14519 byte arg5 ;
14520 bool result;
14521 void *argp1 = 0 ;
14522 int res1 = 0 ;
14523 void *argp2 = 0 ;
14524 int res2 = 0 ;
14525 unsigned char val3 ;
14526 int ecode3 = 0 ;
14527 unsigned char val4 ;
14528 int ecode4 = 0 ;
14529 unsigned char val5 ;
14530 int ecode5 = 0 ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 PyObject * obj2 = 0 ;
14534 PyObject * obj3 = 0 ;
14535 PyObject * obj4 = 0 ;
14536 char * kwnames[] = {
14537 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14538 };
14539
14540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14542 if (!SWIG_IsOK(res1)) {
14543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14544 }
14545 arg1 = reinterpret_cast< wxImage * >(argp1);
14546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14547 if (!SWIG_IsOK(res2)) {
14548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14549 }
14550 if (!argp2) {
14551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14552 }
14553 arg2 = reinterpret_cast< wxImage * >(argp2);
14554 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14555 if (!SWIG_IsOK(ecode3)) {
14556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14557 }
14558 arg3 = static_cast< byte >(val3);
14559 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14560 if (!SWIG_IsOK(ecode4)) {
14561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14562 }
14563 arg4 = static_cast< byte >(val4);
14564 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14565 if (!SWIG_IsOK(ecode5)) {
14566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14567 }
14568 arg5 = static_cast< byte >(val5);
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 {
14576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14577 }
14578 return resultobj;
14579 fail:
14580 return NULL;
14581 }
14582
14583
14584 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14585 PyObject *resultobj = 0;
14586 wxString *arg1 = 0 ;
14587 bool result;
14588 bool temp1 = false ;
14589 PyObject * obj0 = 0 ;
14590 char * kwnames[] = {
14591 (char *) "filename", NULL
14592 };
14593
14594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14595 {
14596 arg1 = wxString_in_helper(obj0);
14597 if (arg1 == NULL) SWIG_fail;
14598 temp1 = true;
14599 }
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 {
14607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14608 }
14609 {
14610 if (temp1)
14611 delete arg1;
14612 }
14613 return resultobj;
14614 fail:
14615 {
14616 if (temp1)
14617 delete arg1;
14618 }
14619 return NULL;
14620 }
14621
14622
14623 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14624 PyObject *resultobj = 0;
14625 wxString *arg1 = 0 ;
14626 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14627 int result;
14628 bool temp1 = false ;
14629 long val2 ;
14630 int ecode2 = 0 ;
14631 PyObject * obj0 = 0 ;
14632 PyObject * obj1 = 0 ;
14633 char * kwnames[] = {
14634 (char *) "filename",(char *) "type", NULL
14635 };
14636
14637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14638 {
14639 arg1 = wxString_in_helper(obj0);
14640 if (arg1 == NULL) SWIG_fail;
14641 temp1 = true;
14642 }
14643 if (obj1) {
14644 ecode2 = SWIG_AsVal_long(obj1, &val2);
14645 if (!SWIG_IsOK(ecode2)) {
14646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14647 }
14648 arg2 = static_cast< long >(val2);
14649 }
14650 {
14651 PyThreadState* __tstate = wxPyBeginAllowThreads();
14652 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14653 wxPyEndAllowThreads(__tstate);
14654 if (PyErr_Occurred()) SWIG_fail;
14655 }
14656 resultobj = SWIG_From_int(static_cast< int >(result));
14657 {
14658 if (temp1)
14659 delete arg1;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp1)
14665 delete arg1;
14666 }
14667 return NULL;
14668 }
14669
14670
14671 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj = 0;
14673 wxImage *arg1 = (wxImage *) 0 ;
14674 wxString *arg2 = 0 ;
14675 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14676 int arg4 = (int) -1 ;
14677 bool result;
14678 void *argp1 = 0 ;
14679 int res1 = 0 ;
14680 bool temp2 = false ;
14681 long val3 ;
14682 int ecode3 = 0 ;
14683 int val4 ;
14684 int ecode4 = 0 ;
14685 PyObject * obj0 = 0 ;
14686 PyObject * obj1 = 0 ;
14687 PyObject * obj2 = 0 ;
14688 PyObject * obj3 = 0 ;
14689 char * kwnames[] = {
14690 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14691 };
14692
14693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14695 if (!SWIG_IsOK(res1)) {
14696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14697 }
14698 arg1 = reinterpret_cast< wxImage * >(argp1);
14699 {
14700 arg2 = wxString_in_helper(obj1);
14701 if (arg2 == NULL) SWIG_fail;
14702 temp2 = true;
14703 }
14704 if (obj2) {
14705 ecode3 = SWIG_AsVal_long(obj2, &val3);
14706 if (!SWIG_IsOK(ecode3)) {
14707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14708 }
14709 arg3 = static_cast< long >(val3);
14710 }
14711 if (obj3) {
14712 ecode4 = SWIG_AsVal_int(obj3, &val4);
14713 if (!SWIG_IsOK(ecode4)) {
14714 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14715 }
14716 arg4 = static_cast< int >(val4);
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 {
14725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14726 }
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 return resultobj;
14732 fail:
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 return NULL;
14738 }
14739
14740
14741 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj = 0;
14743 wxImage *arg1 = (wxImage *) 0 ;
14744 wxString *arg2 = 0 ;
14745 wxString *arg3 = 0 ;
14746 int arg4 = (int) -1 ;
14747 bool result;
14748 void *argp1 = 0 ;
14749 int res1 = 0 ;
14750 bool temp2 = false ;
14751 bool temp3 = false ;
14752 int val4 ;
14753 int ecode4 = 0 ;
14754 PyObject * obj0 = 0 ;
14755 PyObject * obj1 = 0 ;
14756 PyObject * obj2 = 0 ;
14757 PyObject * obj3 = 0 ;
14758 char * kwnames[] = {
14759 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14760 };
14761
14762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14764 if (!SWIG_IsOK(res1)) {
14765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14766 }
14767 arg1 = reinterpret_cast< wxImage * >(argp1);
14768 {
14769 arg2 = wxString_in_helper(obj1);
14770 if (arg2 == NULL) SWIG_fail;
14771 temp2 = true;
14772 }
14773 {
14774 arg3 = wxString_in_helper(obj2);
14775 if (arg3 == NULL) SWIG_fail;
14776 temp3 = true;
14777 }
14778 if (obj3) {
14779 ecode4 = SWIG_AsVal_int(obj3, &val4);
14780 if (!SWIG_IsOK(ecode4)) {
14781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14782 }
14783 arg4 = static_cast< int >(val4);
14784 }
14785 {
14786 PyThreadState* __tstate = wxPyBeginAllowThreads();
14787 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 {
14792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14793 }
14794 {
14795 if (temp2)
14796 delete arg2;
14797 }
14798 {
14799 if (temp3)
14800 delete arg3;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (temp2)
14806 delete arg2;
14807 }
14808 {
14809 if (temp3)
14810 delete arg3;
14811 }
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj = 0;
14818 wxImage *arg1 = (wxImage *) 0 ;
14819 wxString *arg2 = 0 ;
14820 int arg3 ;
14821 bool result;
14822 void *argp1 = 0 ;
14823 int res1 = 0 ;
14824 bool temp2 = false ;
14825 int val3 ;
14826 int ecode3 = 0 ;
14827 PyObject * obj0 = 0 ;
14828 PyObject * obj1 = 0 ;
14829 PyObject * obj2 = 0 ;
14830 char * kwnames[] = {
14831 (char *) "self",(char *) "name",(char *) "type", NULL
14832 };
14833
14834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14838 }
14839 arg1 = reinterpret_cast< wxImage * >(argp1);
14840 {
14841 arg2 = wxString_in_helper(obj1);
14842 if (arg2 == NULL) SWIG_fail;
14843 temp2 = true;
14844 }
14845 ecode3 = SWIG_AsVal_int(obj2, &val3);
14846 if (!SWIG_IsOK(ecode3)) {
14847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14848 }
14849 arg3 = static_cast< int >(val3);
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (temp2)
14861 delete arg2;
14862 }
14863 return resultobj;
14864 fail:
14865 {
14866 if (temp2)
14867 delete arg2;
14868 }
14869 return NULL;
14870 }
14871
14872
14873 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj = 0;
14875 wxImage *arg1 = (wxImage *) 0 ;
14876 wxString *arg2 = 0 ;
14877 wxString *arg3 = 0 ;
14878 bool result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 bool temp2 = false ;
14882 bool temp3 = false ;
14883 PyObject * obj0 = 0 ;
14884 PyObject * obj1 = 0 ;
14885 PyObject * obj2 = 0 ;
14886 char * kwnames[] = {
14887 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14888 };
14889
14890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14892 if (!SWIG_IsOK(res1)) {
14893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14894 }
14895 arg1 = reinterpret_cast< wxImage * >(argp1);
14896 {
14897 arg2 = wxString_in_helper(obj1);
14898 if (arg2 == NULL) SWIG_fail;
14899 temp2 = true;
14900 }
14901 {
14902 arg3 = wxString_in_helper(obj2);
14903 if (arg3 == NULL) SWIG_fail;
14904 temp3 = true;
14905 }
14906 {
14907 PyThreadState* __tstate = wxPyBeginAllowThreads();
14908 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14909 wxPyEndAllowThreads(__tstate);
14910 if (PyErr_Occurred()) SWIG_fail;
14911 }
14912 {
14913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14914 }
14915 {
14916 if (temp2)
14917 delete arg2;
14918 }
14919 {
14920 if (temp3)
14921 delete arg3;
14922 }
14923 return resultobj;
14924 fail:
14925 {
14926 if (temp2)
14927 delete arg2;
14928 }
14929 {
14930 if (temp3)
14931 delete arg3;
14932 }
14933 return NULL;
14934 }
14935
14936
14937 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj = 0;
14939 wxInputStream *arg1 = 0 ;
14940 bool result;
14941 wxPyInputStream *temp1 ;
14942 bool created1 ;
14943 PyObject * obj0 = 0 ;
14944 char * kwnames[] = {
14945 (char *) "stream", NULL
14946 };
14947
14948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14949 {
14950 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14951 arg1 = temp1->m_wxis;
14952 created1 = false;
14953 } else {
14954 PyErr_Clear(); // clear the failure of the wxPyConvert above
14955 arg1 = wxPyCBInputStream_create(obj0, false);
14956 if (arg1 == NULL) {
14957 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14958 SWIG_fail;
14959 }
14960 created1 = true;
14961 }
14962 }
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = (bool)wxImage::CanRead(*arg1);
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 {
14970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14971 }
14972 {
14973 if (created1) delete arg1;
14974 }
14975 return resultobj;
14976 fail:
14977 {
14978 if (created1) delete arg1;
14979 }
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14985 PyObject *resultobj = 0;
14986 wxImage *arg1 = (wxImage *) 0 ;
14987 wxInputStream *arg2 = 0 ;
14988 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14989 int arg4 = (int) -1 ;
14990 bool result;
14991 void *argp1 = 0 ;
14992 int res1 = 0 ;
14993 wxPyInputStream *temp2 ;
14994 bool created2 ;
14995 long val3 ;
14996 int ecode3 = 0 ;
14997 int val4 ;
14998 int ecode4 = 0 ;
14999 PyObject * obj0 = 0 ;
15000 PyObject * obj1 = 0 ;
15001 PyObject * obj2 = 0 ;
15002 PyObject * obj3 = 0 ;
15003 char * kwnames[] = {
15004 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15005 };
15006
15007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15011 }
15012 arg1 = reinterpret_cast< wxImage * >(argp1);
15013 {
15014 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15015 arg2 = temp2->m_wxis;
15016 created2 = false;
15017 } else {
15018 PyErr_Clear(); // clear the failure of the wxPyConvert above
15019 arg2 = wxPyCBInputStream_create(obj1, false);
15020 if (arg2 == NULL) {
15021 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15022 SWIG_fail;
15023 }
15024 created2 = true;
15025 }
15026 }
15027 if (obj2) {
15028 ecode3 = SWIG_AsVal_long(obj2, &val3);
15029 if (!SWIG_IsOK(ecode3)) {
15030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15031 }
15032 arg3 = static_cast< long >(val3);
15033 }
15034 if (obj3) {
15035 ecode4 = SWIG_AsVal_int(obj3, &val4);
15036 if (!SWIG_IsOK(ecode4)) {
15037 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15038 }
15039 arg4 = static_cast< int >(val4);
15040 }
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15044 wxPyEndAllowThreads(__tstate);
15045 if (PyErr_Occurred()) SWIG_fail;
15046 }
15047 {
15048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15049 }
15050 {
15051 if (created2) delete arg2;
15052 }
15053 return resultobj;
15054 fail:
15055 {
15056 if (created2) delete arg2;
15057 }
15058 return NULL;
15059 }
15060
15061
15062 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15063 PyObject *resultobj = 0;
15064 wxImage *arg1 = (wxImage *) 0 ;
15065 wxInputStream *arg2 = 0 ;
15066 wxString *arg3 = 0 ;
15067 int arg4 = (int) -1 ;
15068 bool result;
15069 void *argp1 = 0 ;
15070 int res1 = 0 ;
15071 wxPyInputStream *temp2 ;
15072 bool created2 ;
15073 bool temp3 = false ;
15074 int val4 ;
15075 int ecode4 = 0 ;
15076 PyObject * obj0 = 0 ;
15077 PyObject * obj1 = 0 ;
15078 PyObject * obj2 = 0 ;
15079 PyObject * obj3 = 0 ;
15080 char * kwnames[] = {
15081 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15082 };
15083
15084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15088 }
15089 arg1 = reinterpret_cast< wxImage * >(argp1);
15090 {
15091 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15092 arg2 = temp2->m_wxis;
15093 created2 = false;
15094 } else {
15095 PyErr_Clear(); // clear the failure of the wxPyConvert above
15096 arg2 = wxPyCBInputStream_create(obj1, false);
15097 if (arg2 == NULL) {
15098 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15099 SWIG_fail;
15100 }
15101 created2 = true;
15102 }
15103 }
15104 {
15105 arg3 = wxString_in_helper(obj2);
15106 if (arg3 == NULL) SWIG_fail;
15107 temp3 = true;
15108 }
15109 if (obj3) {
15110 ecode4 = SWIG_AsVal_int(obj3, &val4);
15111 if (!SWIG_IsOK(ecode4)) {
15112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15113 }
15114 arg4 = static_cast< int >(val4);
15115 }
15116 {
15117 PyThreadState* __tstate = wxPyBeginAllowThreads();
15118 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 {
15123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15124 }
15125 {
15126 if (created2) delete arg2;
15127 }
15128 {
15129 if (temp3)
15130 delete arg3;
15131 }
15132 return resultobj;
15133 fail:
15134 {
15135 if (created2) delete arg2;
15136 }
15137 {
15138 if (temp3)
15139 delete arg3;
15140 }
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15146 PyObject *resultobj = 0;
15147 wxImage *arg1 = (wxImage *) 0 ;
15148 bool result;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 PyObject *swig_obj[1] ;
15152
15153 if (!args) SWIG_fail;
15154 swig_obj[0] = args;
15155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15158 }
15159 arg1 = reinterpret_cast< wxImage * >(argp1);
15160 {
15161 PyThreadState* __tstate = wxPyBeginAllowThreads();
15162 result = (bool)(arg1)->Ok();
15163 wxPyEndAllowThreads(__tstate);
15164 if (PyErr_Occurred()) SWIG_fail;
15165 }
15166 {
15167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15168 }
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15176 PyObject *resultobj = 0;
15177 wxImage *arg1 = (wxImage *) 0 ;
15178 int result;
15179 void *argp1 = 0 ;
15180 int res1 = 0 ;
15181 PyObject *swig_obj[1] ;
15182
15183 if (!args) SWIG_fail;
15184 swig_obj[0] = args;
15185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15186 if (!SWIG_IsOK(res1)) {
15187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15188 }
15189 arg1 = reinterpret_cast< wxImage * >(argp1);
15190 {
15191 PyThreadState* __tstate = wxPyBeginAllowThreads();
15192 result = (int)(arg1)->GetWidth();
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 resultobj = SWIG_From_int(static_cast< int >(result));
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15204 PyObject *resultobj = 0;
15205 wxImage *arg1 = (wxImage *) 0 ;
15206 int result;
15207 void *argp1 = 0 ;
15208 int res1 = 0 ;
15209 PyObject *swig_obj[1] ;
15210
15211 if (!args) SWIG_fail;
15212 swig_obj[0] = args;
15213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 PyThreadState* __tstate = wxPyBeginAllowThreads();
15220 result = (int)(arg1)->GetHeight();
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = SWIG_From_int(static_cast< int >(result));
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15232 PyObject *resultobj = 0;
15233 wxImage *arg1 = (wxImage *) 0 ;
15234 wxSize result;
15235 void *argp1 = 0 ;
15236 int res1 = 0 ;
15237 PyObject *swig_obj[1] ;
15238
15239 if (!args) SWIG_fail;
15240 swig_obj[0] = args;
15241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15242 if (!SWIG_IsOK(res1)) {
15243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15244 }
15245 arg1 = reinterpret_cast< wxImage * >(argp1);
15246 {
15247 PyThreadState* __tstate = wxPyBeginAllowThreads();
15248 result = wxImage_GetSize(arg1);
15249 wxPyEndAllowThreads(__tstate);
15250 if (PyErr_Occurred()) SWIG_fail;
15251 }
15252 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15253 return resultobj;
15254 fail:
15255 return NULL;
15256 }
15257
15258
15259 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15260 PyObject *resultobj = 0;
15261 wxImage *arg1 = (wxImage *) 0 ;
15262 wxRect *arg2 = 0 ;
15263 SwigValueWrapper<wxImage > result;
15264 void *argp1 = 0 ;
15265 int res1 = 0 ;
15266 wxRect temp2 ;
15267 PyObject * obj0 = 0 ;
15268 PyObject * obj1 = 0 ;
15269 char * kwnames[] = {
15270 (char *) "self",(char *) "rect", NULL
15271 };
15272
15273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15275 if (!SWIG_IsOK(res1)) {
15276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15277 }
15278 arg1 = reinterpret_cast< wxImage * >(argp1);
15279 {
15280 arg2 = &temp2;
15281 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15282 }
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15286 wxPyEndAllowThreads(__tstate);
15287 if (PyErr_Occurred()) SWIG_fail;
15288 }
15289 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15297 PyObject *resultobj = 0;
15298 wxImage *arg1 = (wxImage *) 0 ;
15299 wxSize *arg2 = 0 ;
15300 wxPoint *arg3 = 0 ;
15301 int arg4 = (int) -1 ;
15302 int arg5 = (int) -1 ;
15303 int arg6 = (int) -1 ;
15304 SwigValueWrapper<wxImage > result;
15305 void *argp1 = 0 ;
15306 int res1 = 0 ;
15307 wxSize temp2 ;
15308 wxPoint temp3 ;
15309 int val4 ;
15310 int ecode4 = 0 ;
15311 int val5 ;
15312 int ecode5 = 0 ;
15313 int val6 ;
15314 int ecode6 = 0 ;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 PyObject * obj2 = 0 ;
15318 PyObject * obj3 = 0 ;
15319 PyObject * obj4 = 0 ;
15320 PyObject * obj5 = 0 ;
15321 char * kwnames[] = {
15322 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15323 };
15324
15325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15329 }
15330 arg1 = reinterpret_cast< wxImage * >(argp1);
15331 {
15332 arg2 = &temp2;
15333 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15334 }
15335 {
15336 arg3 = &temp3;
15337 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15338 }
15339 if (obj3) {
15340 ecode4 = SWIG_AsVal_int(obj3, &val4);
15341 if (!SWIG_IsOK(ecode4)) {
15342 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15343 }
15344 arg4 = static_cast< int >(val4);
15345 }
15346 if (obj4) {
15347 ecode5 = SWIG_AsVal_int(obj4, &val5);
15348 if (!SWIG_IsOK(ecode5)) {
15349 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15350 }
15351 arg5 = static_cast< int >(val5);
15352 }
15353 if (obj5) {
15354 ecode6 = SWIG_AsVal_int(obj5, &val6);
15355 if (!SWIG_IsOK(ecode6)) {
15356 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15357 }
15358 arg6 = static_cast< int >(val6);
15359 }
15360 {
15361 PyThreadState* __tstate = wxPyBeginAllowThreads();
15362 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15367 return resultobj;
15368 fail:
15369 return NULL;
15370 }
15371
15372
15373 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15374 PyObject *resultobj = 0;
15375 wxImage *arg1 = (wxImage *) 0 ;
15376 SwigValueWrapper<wxImage > result;
15377 void *argp1 = 0 ;
15378 int res1 = 0 ;
15379 PyObject *swig_obj[1] ;
15380
15381 if (!args) SWIG_fail;
15382 swig_obj[0] = args;
15383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15384 if (!SWIG_IsOK(res1)) {
15385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15386 }
15387 arg1 = reinterpret_cast< wxImage * >(argp1);
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 result = (arg1)->Copy();
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj = 0;
15403 wxImage *arg1 = (wxImage *) 0 ;
15404 wxImage *arg2 = 0 ;
15405 int arg3 ;
15406 int arg4 ;
15407 void *argp1 = 0 ;
15408 int res1 = 0 ;
15409 void *argp2 = 0 ;
15410 int res2 = 0 ;
15411 int val3 ;
15412 int ecode3 = 0 ;
15413 int val4 ;
15414 int ecode4 = 0 ;
15415 PyObject * obj0 = 0 ;
15416 PyObject * obj1 = 0 ;
15417 PyObject * obj2 = 0 ;
15418 PyObject * obj3 = 0 ;
15419 char * kwnames[] = {
15420 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15421 };
15422
15423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15427 }
15428 arg1 = reinterpret_cast< wxImage * >(argp1);
15429 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15430 if (!SWIG_IsOK(res2)) {
15431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15432 }
15433 if (!argp2) {
15434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15435 }
15436 arg2 = reinterpret_cast< wxImage * >(argp2);
15437 ecode3 = SWIG_AsVal_int(obj2, &val3);
15438 if (!SWIG_IsOK(ecode3)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15440 }
15441 arg3 = static_cast< int >(val3);
15442 ecode4 = SWIG_AsVal_int(obj3, &val4);
15443 if (!SWIG_IsOK(ecode4)) {
15444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15445 }
15446 arg4 = static_cast< int >(val4);
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_Py_Void();
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15461 PyObject *resultobj = 0;
15462 wxImage *arg1 = (wxImage *) 0 ;
15463 PyObject *result = 0 ;
15464 void *argp1 = 0 ;
15465 int res1 = 0 ;
15466 PyObject *swig_obj[1] ;
15467
15468 if (!args) SWIG_fail;
15469 swig_obj[0] = args;
15470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15471 if (!SWIG_IsOK(res1)) {
15472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15473 }
15474 arg1 = reinterpret_cast< wxImage * >(argp1);
15475 {
15476 PyThreadState* __tstate = wxPyBeginAllowThreads();
15477 result = (PyObject *)wxImage_GetData(arg1);
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 resultobj = result;
15482 return resultobj;
15483 fail:
15484 return NULL;
15485 }
15486
15487
15488 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15489 PyObject *resultobj = 0;
15490 wxImage *arg1 = (wxImage *) 0 ;
15491 buffer arg2 ;
15492 int arg3 ;
15493 void *argp1 = 0 ;
15494 int res1 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char * kwnames[] = {
15498 (char *) "self",(char *) "data", NULL
15499 };
15500
15501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15505 }
15506 arg1 = reinterpret_cast< wxImage * >(argp1);
15507 {
15508 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15509 }
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 wxImage_SetData(arg1,arg2,arg3);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxImage *arg1 = (wxImage *) 0 ;
15526 PyObject *result = 0 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15536 }
15537 arg1 = reinterpret_cast< wxImage * >(argp1);
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = result;
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = 0;
15553 wxImage *arg1 = (wxImage *) 0 ;
15554 buffer arg2 ;
15555 int arg3 ;
15556 void *argp1 = 0 ;
15557 int res1 = 0 ;
15558 PyObject * obj0 = 0 ;
15559 PyObject * obj1 = 0 ;
15560 char * kwnames[] = {
15561 (char *) "self",(char *) "data", NULL
15562 };
15563
15564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15566 if (!SWIG_IsOK(res1)) {
15567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15568 }
15569 arg1 = reinterpret_cast< wxImage * >(argp1);
15570 {
15571 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15572 }
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 wxImage_SetDataBuffer(arg1,arg2,arg3);
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 resultobj = SWIG_Py_Void();
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15587 PyObject *resultobj = 0;
15588 wxImage *arg1 = (wxImage *) 0 ;
15589 PyObject *result = 0 ;
15590 void *argp1 = 0 ;
15591 int res1 = 0 ;
15592 PyObject *swig_obj[1] ;
15593
15594 if (!args) SWIG_fail;
15595 swig_obj[0] = args;
15596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15597 if (!SWIG_IsOK(res1)) {
15598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15599 }
15600 arg1 = reinterpret_cast< wxImage * >(argp1);
15601 {
15602 PyThreadState* __tstate = wxPyBeginAllowThreads();
15603 result = (PyObject *)wxImage_GetAlphaData(arg1);
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 resultobj = result;
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15615 PyObject *resultobj = 0;
15616 wxImage *arg1 = (wxImage *) 0 ;
15617 buffer arg2 ;
15618 int arg3 ;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 PyObject * obj0 = 0 ;
15622 PyObject * obj1 = 0 ;
15623 char * kwnames[] = {
15624 (char *) "self",(char *) "alpha", NULL
15625 };
15626
15627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15629 if (!SWIG_IsOK(res1)) {
15630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15631 }
15632 arg1 = reinterpret_cast< wxImage * >(argp1);
15633 {
15634 if (obj1 != Py_None) {
15635 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15636 }
15637 }
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 wxImage_SetAlphaData(arg1,arg2,arg3);
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_Py_Void();
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 PyObject *result = 0 ;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 PyObject *swig_obj[1] ;
15658
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15664 }
15665 arg1 = reinterpret_cast< wxImage * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 resultobj = result;
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 buffer arg2 ;
15683 int arg3 ;
15684 void *argp1 = 0 ;
15685 int res1 = 0 ;
15686 PyObject * obj0 = 0 ;
15687 PyObject * obj1 = 0 ;
15688 char * kwnames[] = {
15689 (char *) "self",(char *) "alpha", NULL
15690 };
15691
15692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15694 if (!SWIG_IsOK(res1)) {
15695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15696 }
15697 arg1 = reinterpret_cast< wxImage * >(argp1);
15698 {
15699 if (obj1 != Py_None) {
15700 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15701 }
15702 }
15703 {
15704 PyThreadState* __tstate = wxPyBeginAllowThreads();
15705 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 resultobj = SWIG_Py_Void();
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15717 PyObject *resultobj = 0;
15718 wxImage *arg1 = (wxImage *) 0 ;
15719 byte arg2 ;
15720 byte arg3 ;
15721 byte arg4 ;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 unsigned char val2 ;
15725 int ecode2 = 0 ;
15726 unsigned char val3 ;
15727 int ecode3 = 0 ;
15728 unsigned char val4 ;
15729 int ecode4 = 0 ;
15730 PyObject * obj0 = 0 ;
15731 PyObject * obj1 = 0 ;
15732 PyObject * obj2 = 0 ;
15733 PyObject * obj3 = 0 ;
15734 char * kwnames[] = {
15735 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15736 };
15737
15738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15742 }
15743 arg1 = reinterpret_cast< wxImage * >(argp1);
15744 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15745 if (!SWIG_IsOK(ecode2)) {
15746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15747 }
15748 arg2 = static_cast< byte >(val2);
15749 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15750 if (!SWIG_IsOK(ecode3)) {
15751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15752 }
15753 arg3 = static_cast< byte >(val3);
15754 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15755 if (!SWIG_IsOK(ecode4)) {
15756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15757 }
15758 arg4 = static_cast< byte >(val4);
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 (arg1)->SetMaskColour(arg2,arg3,arg4);
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 resultobj = SWIG_Py_Void();
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15773 PyObject *resultobj = 0;
15774 wxImage *arg1 = (wxImage *) 0 ;
15775 byte *arg2 = (byte *) 0 ;
15776 byte *arg3 = (byte *) 0 ;
15777 byte *arg4 = (byte *) 0 ;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 byte temp2 ;
15781 int res2 = SWIG_TMPOBJ ;
15782 byte temp3 ;
15783 int res3 = SWIG_TMPOBJ ;
15784 byte temp4 ;
15785 int res4 = SWIG_TMPOBJ ;
15786 PyObject *swig_obj[1] ;
15787
15788 arg2 = &temp2;
15789 arg3 = &temp3;
15790 arg4 = &temp4;
15791 if (!args) SWIG_fail;
15792 swig_obj[0] = args;
15793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15794 if (!SWIG_IsOK(res1)) {
15795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15796 }
15797 arg1 = reinterpret_cast< wxImage * >(argp1);
15798 {
15799 PyThreadState* __tstate = wxPyBeginAllowThreads();
15800 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15801 wxPyEndAllowThreads(__tstate);
15802 if (PyErr_Occurred()) SWIG_fail;
15803 }
15804 resultobj = SWIG_Py_Void();
15805 if (SWIG_IsTmpObj(res2)) {
15806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15807 } else {
15808 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15810 }
15811 if (SWIG_IsTmpObj(res3)) {
15812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15813 } else {
15814 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15816 }
15817 if (SWIG_IsTmpObj(res4)) {
15818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15819 } else {
15820 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15822 }
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15830 PyObject *resultobj = 0;
15831 wxImage *arg1 = (wxImage *) 0 ;
15832 byte result;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject *swig_obj[1] ;
15836
15837 if (!args) SWIG_fail;
15838 swig_obj[0] = args;
15839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15840 if (!SWIG_IsOK(res1)) {
15841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15842 }
15843 arg1 = reinterpret_cast< wxImage * >(argp1);
15844 {
15845 PyThreadState* __tstate = wxPyBeginAllowThreads();
15846 result = (byte)(arg1)->GetMaskRed();
15847 wxPyEndAllowThreads(__tstate);
15848 if (PyErr_Occurred()) SWIG_fail;
15849 }
15850 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15851 return resultobj;
15852 fail:
15853 return NULL;
15854 }
15855
15856
15857 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15858 PyObject *resultobj = 0;
15859 wxImage *arg1 = (wxImage *) 0 ;
15860 byte result;
15861 void *argp1 = 0 ;
15862 int res1 = 0 ;
15863 PyObject *swig_obj[1] ;
15864
15865 if (!args) SWIG_fail;
15866 swig_obj[0] = args;
15867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15868 if (!SWIG_IsOK(res1)) {
15869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15870 }
15871 arg1 = reinterpret_cast< wxImage * >(argp1);
15872 {
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (byte)(arg1)->GetMaskGreen();
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15886 PyObject *resultobj = 0;
15887 wxImage *arg1 = (wxImage *) 0 ;
15888 byte result;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15898 }
15899 arg1 = reinterpret_cast< wxImage * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (byte)(arg1)->GetMaskBlue();
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj = 0;
15915 wxImage *arg1 = (wxImage *) 0 ;
15916 bool arg2 = (bool) true ;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 bool val2 ;
15920 int ecode2 = 0 ;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 char * kwnames[] = {
15924 (char *) "self",(char *) "mask", NULL
15925 };
15926
15927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15929 if (!SWIG_IsOK(res1)) {
15930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15931 }
15932 arg1 = reinterpret_cast< wxImage * >(argp1);
15933 if (obj1) {
15934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15935 if (!SWIG_IsOK(ecode2)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15937 }
15938 arg2 = static_cast< bool >(val2);
15939 }
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 (arg1)->SetMask(arg2);
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_Py_Void();
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15954 PyObject *resultobj = 0;
15955 wxImage *arg1 = (wxImage *) 0 ;
15956 bool result;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 PyObject *swig_obj[1] ;
15960
15961 if (!args) SWIG_fail;
15962 swig_obj[0] = args;
15963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15964 if (!SWIG_IsOK(res1)) {
15965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15966 }
15967 arg1 = reinterpret_cast< wxImage * >(argp1);
15968 {
15969 PyThreadState* __tstate = wxPyBeginAllowThreads();
15970 result = (bool)(arg1)->HasMask();
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 {
15975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15976 }
15977 return resultobj;
15978 fail:
15979 return NULL;
15980 }
15981
15982
15983 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15984 PyObject *resultobj = 0;
15985 wxImage *arg1 = (wxImage *) 0 ;
15986 double arg2 ;
15987 wxPoint *arg3 = 0 ;
15988 bool arg4 = (bool) true ;
15989 wxPoint *arg5 = (wxPoint *) NULL ;
15990 SwigValueWrapper<wxImage > result;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 double val2 ;
15994 int ecode2 = 0 ;
15995 wxPoint temp3 ;
15996 bool val4 ;
15997 int ecode4 = 0 ;
15998 void *argp5 = 0 ;
15999 int res5 = 0 ;
16000 PyObject * obj0 = 0 ;
16001 PyObject * obj1 = 0 ;
16002 PyObject * obj2 = 0 ;
16003 PyObject * obj3 = 0 ;
16004 PyObject * obj4 = 0 ;
16005 char * kwnames[] = {
16006 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16007 };
16008
16009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16011 if (!SWIG_IsOK(res1)) {
16012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16013 }
16014 arg1 = reinterpret_cast< wxImage * >(argp1);
16015 ecode2 = SWIG_AsVal_double(obj1, &val2);
16016 if (!SWIG_IsOK(ecode2)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16018 }
16019 arg2 = static_cast< double >(val2);
16020 {
16021 arg3 = &temp3;
16022 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16023 }
16024 if (obj3) {
16025 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16026 if (!SWIG_IsOK(ecode4)) {
16027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16028 }
16029 arg4 = static_cast< bool >(val4);
16030 }
16031 if (obj4) {
16032 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16033 if (!SWIG_IsOK(res5)) {
16034 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16035 }
16036 arg5 = reinterpret_cast< wxPoint * >(argp5);
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16041 wxPyEndAllowThreads(__tstate);
16042 if (PyErr_Occurred()) SWIG_fail;
16043 }
16044 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16045 return resultobj;
16046 fail:
16047 return NULL;
16048 }
16049
16050
16051 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj = 0;
16053 wxImage *arg1 = (wxImage *) 0 ;
16054 bool arg2 = (bool) true ;
16055 SwigValueWrapper<wxImage > result;
16056 void *argp1 = 0 ;
16057 int res1 = 0 ;
16058 bool val2 ;
16059 int ecode2 = 0 ;
16060 PyObject * obj0 = 0 ;
16061 PyObject * obj1 = 0 ;
16062 char * kwnames[] = {
16063 (char *) "self",(char *) "clockwise", NULL
16064 };
16065
16066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16068 if (!SWIG_IsOK(res1)) {
16069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16070 }
16071 arg1 = reinterpret_cast< wxImage * >(argp1);
16072 if (obj1) {
16073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16074 if (!SWIG_IsOK(ecode2)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16076 }
16077 arg2 = static_cast< bool >(val2);
16078 }
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (arg1)->Rotate90(arg2);
16082 wxPyEndAllowThreads(__tstate);
16083 if (PyErr_Occurred()) SWIG_fail;
16084 }
16085 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16086 return resultobj;
16087 fail:
16088 return NULL;
16089 }
16090
16091
16092 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16093 PyObject *resultobj = 0;
16094 wxImage *arg1 = (wxImage *) 0 ;
16095 bool arg2 = (bool) true ;
16096 SwigValueWrapper<wxImage > result;
16097 void *argp1 = 0 ;
16098 int res1 = 0 ;
16099 bool val2 ;
16100 int ecode2 = 0 ;
16101 PyObject * obj0 = 0 ;
16102 PyObject * obj1 = 0 ;
16103 char * kwnames[] = {
16104 (char *) "self",(char *) "horizontally", NULL
16105 };
16106
16107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16109 if (!SWIG_IsOK(res1)) {
16110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16111 }
16112 arg1 = reinterpret_cast< wxImage * >(argp1);
16113 if (obj1) {
16114 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16115 if (!SWIG_IsOK(ecode2)) {
16116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16117 }
16118 arg2 = static_cast< bool >(val2);
16119 }
16120 {
16121 PyThreadState* __tstate = wxPyBeginAllowThreads();
16122 result = (arg1)->Mirror(arg2);
16123 wxPyEndAllowThreads(__tstate);
16124 if (PyErr_Occurred()) SWIG_fail;
16125 }
16126 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16127 return resultobj;
16128 fail:
16129 return NULL;
16130 }
16131
16132
16133 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16134 PyObject *resultobj = 0;
16135 wxImage *arg1 = (wxImage *) 0 ;
16136 byte arg2 ;
16137 byte arg3 ;
16138 byte arg4 ;
16139 byte arg5 ;
16140 byte arg6 ;
16141 byte arg7 ;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 unsigned char val2 ;
16145 int ecode2 = 0 ;
16146 unsigned char val3 ;
16147 int ecode3 = 0 ;
16148 unsigned char val4 ;
16149 int ecode4 = 0 ;
16150 unsigned char val5 ;
16151 int ecode5 = 0 ;
16152 unsigned char val6 ;
16153 int ecode6 = 0 ;
16154 unsigned char val7 ;
16155 int ecode7 = 0 ;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 PyObject * obj2 = 0 ;
16159 PyObject * obj3 = 0 ;
16160 PyObject * obj4 = 0 ;
16161 PyObject * obj5 = 0 ;
16162 PyObject * obj6 = 0 ;
16163 char * kwnames[] = {
16164 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16165 };
16166
16167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16169 if (!SWIG_IsOK(res1)) {
16170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16171 }
16172 arg1 = reinterpret_cast< wxImage * >(argp1);
16173 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16174 if (!SWIG_IsOK(ecode2)) {
16175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16176 }
16177 arg2 = static_cast< byte >(val2);
16178 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16179 if (!SWIG_IsOK(ecode3)) {
16180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16181 }
16182 arg3 = static_cast< byte >(val3);
16183 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16184 if (!SWIG_IsOK(ecode4)) {
16185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16186 }
16187 arg4 = static_cast< byte >(val4);
16188 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16189 if (!SWIG_IsOK(ecode5)) {
16190 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16191 }
16192 arg5 = static_cast< byte >(val5);
16193 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16194 if (!SWIG_IsOK(ecode6)) {
16195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16196 }
16197 arg6 = static_cast< byte >(val6);
16198 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16199 if (!SWIG_IsOK(ecode7)) {
16200 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16201 }
16202 arg7 = static_cast< byte >(val7);
16203 {
16204 PyThreadState* __tstate = wxPyBeginAllowThreads();
16205 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16206 wxPyEndAllowThreads(__tstate);
16207 if (PyErr_Occurred()) SWIG_fail;
16208 }
16209 resultobj = SWIG_Py_Void();
16210 return resultobj;
16211 fail:
16212 return NULL;
16213 }
16214
16215
16216 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16217 PyObject *resultobj = 0;
16218 wxImage *arg1 = (wxImage *) 0 ;
16219 double arg2 = (double) 0.299 ;
16220 double arg3 = (double) 0.587 ;
16221 double arg4 = (double) 0.114 ;
16222 SwigValueWrapper<wxImage > result;
16223 void *argp1 = 0 ;
16224 int res1 = 0 ;
16225 double val2 ;
16226 int ecode2 = 0 ;
16227 double val3 ;
16228 int ecode3 = 0 ;
16229 double val4 ;
16230 int ecode4 = 0 ;
16231 PyObject * obj0 = 0 ;
16232 PyObject * obj1 = 0 ;
16233 PyObject * obj2 = 0 ;
16234 PyObject * obj3 = 0 ;
16235 char * kwnames[] = {
16236 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16237 };
16238
16239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16243 }
16244 arg1 = reinterpret_cast< wxImage * >(argp1);
16245 if (obj1) {
16246 ecode2 = SWIG_AsVal_double(obj1, &val2);
16247 if (!SWIG_IsOK(ecode2)) {
16248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16249 }
16250 arg2 = static_cast< double >(val2);
16251 }
16252 if (obj2) {
16253 ecode3 = SWIG_AsVal_double(obj2, &val3);
16254 if (!SWIG_IsOK(ecode3)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16256 }
16257 arg3 = static_cast< double >(val3);
16258 }
16259 if (obj3) {
16260 ecode4 = SWIG_AsVal_double(obj3, &val4);
16261 if (!SWIG_IsOK(ecode4)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16263 }
16264 arg4 = static_cast< double >(val4);
16265 }
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxImage *arg1 = (wxImage *) 0 ;
16282 byte arg2 ;
16283 byte arg3 ;
16284 byte arg4 ;
16285 SwigValueWrapper<wxImage > result;
16286 void *argp1 = 0 ;
16287 int res1 = 0 ;
16288 unsigned char val2 ;
16289 int ecode2 = 0 ;
16290 unsigned char val3 ;
16291 int ecode3 = 0 ;
16292 unsigned char val4 ;
16293 int ecode4 = 0 ;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 PyObject * obj2 = 0 ;
16297 PyObject * obj3 = 0 ;
16298 char * kwnames[] = {
16299 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16300 };
16301
16302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16306 }
16307 arg1 = reinterpret_cast< wxImage * >(argp1);
16308 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16309 if (!SWIG_IsOK(ecode2)) {
16310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16311 }
16312 arg2 = static_cast< byte >(val2);
16313 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16314 if (!SWIG_IsOK(ecode3)) {
16315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16316 }
16317 arg3 = static_cast< byte >(val3);
16318 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16319 if (!SWIG_IsOK(ecode4)) {
16320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16321 }
16322 arg4 = static_cast< byte >(val4);
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16326 wxPyEndAllowThreads(__tstate);
16327 if (PyErr_Occurred()) SWIG_fail;
16328 }
16329 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16330 return resultobj;
16331 fail:
16332 return NULL;
16333 }
16334
16335
16336 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16337 PyObject *resultobj = 0;
16338 wxImage *arg1 = (wxImage *) 0 ;
16339 wxString *arg2 = 0 ;
16340 wxString *arg3 = 0 ;
16341 void *argp1 = 0 ;
16342 int res1 = 0 ;
16343 bool temp2 = false ;
16344 bool temp3 = false ;
16345 PyObject * obj0 = 0 ;
16346 PyObject * obj1 = 0 ;
16347 PyObject * obj2 = 0 ;
16348 char * kwnames[] = {
16349 (char *) "self",(char *) "name",(char *) "value", NULL
16350 };
16351
16352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) 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_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
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 arg3 = wxString_in_helper(obj2);
16365 if (arg3 == NULL) SWIG_fail;
16366 temp3 = true;
16367 }
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16371 wxPyEndAllowThreads(__tstate);
16372 if (PyErr_Occurred()) SWIG_fail;
16373 }
16374 resultobj = SWIG_Py_Void();
16375 {
16376 if (temp2)
16377 delete arg2;
16378 }
16379 {
16380 if (temp3)
16381 delete arg3;
16382 }
16383 return resultobj;
16384 fail:
16385 {
16386 if (temp2)
16387 delete arg2;
16388 }
16389 {
16390 if (temp3)
16391 delete arg3;
16392 }
16393 return NULL;
16394 }
16395
16396
16397 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj = 0;
16399 wxImage *arg1 = (wxImage *) 0 ;
16400 wxString *arg2 = 0 ;
16401 int arg3 ;
16402 void *argp1 = 0 ;
16403 int res1 = 0 ;
16404 bool temp2 = false ;
16405 int val3 ;
16406 int ecode3 = 0 ;
16407 PyObject * obj0 = 0 ;
16408 PyObject * obj1 = 0 ;
16409 PyObject * obj2 = 0 ;
16410 char * kwnames[] = {
16411 (char *) "self",(char *) "name",(char *) "value", NULL
16412 };
16413
16414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16416 if (!SWIG_IsOK(res1)) {
16417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16418 }
16419 arg1 = reinterpret_cast< wxImage * >(argp1);
16420 {
16421 arg2 = wxString_in_helper(obj1);
16422 if (arg2 == NULL) SWIG_fail;
16423 temp2 = true;
16424 }
16425 ecode3 = SWIG_AsVal_int(obj2, &val3);
16426 if (!SWIG_IsOK(ecode3)) {
16427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16428 }
16429 arg3 = static_cast< int >(val3);
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 (arg1)->SetOption((wxString const &)*arg2,arg3);
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_Py_Void();
16437 {
16438 if (temp2)
16439 delete arg2;
16440 }
16441 return resultobj;
16442 fail:
16443 {
16444 if (temp2)
16445 delete arg2;
16446 }
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxImage *arg1 = (wxImage *) 0 ;
16454 wxString *arg2 = 0 ;
16455 wxString result;
16456 void *argp1 = 0 ;
16457 int res1 = 0 ;
16458 bool temp2 = false ;
16459 PyObject * obj0 = 0 ;
16460 PyObject * obj1 = 0 ;
16461 char * kwnames[] = {
16462 (char *) "self",(char *) "name", NULL
16463 };
16464
16465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16467 if (!SWIG_IsOK(res1)) {
16468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16469 }
16470 arg1 = reinterpret_cast< wxImage * >(argp1);
16471 {
16472 arg2 = wxString_in_helper(obj1);
16473 if (arg2 == NULL) SWIG_fail;
16474 temp2 = true;
16475 }
16476 {
16477 PyThreadState* __tstate = wxPyBeginAllowThreads();
16478 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 {
16483 #if wxUSE_UNICODE
16484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16485 #else
16486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16487 #endif
16488 }
16489 {
16490 if (temp2)
16491 delete arg2;
16492 }
16493 return resultobj;
16494 fail:
16495 {
16496 if (temp2)
16497 delete arg2;
16498 }
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = 0;
16505 wxImage *arg1 = (wxImage *) 0 ;
16506 wxString *arg2 = 0 ;
16507 int result;
16508 void *argp1 = 0 ;
16509 int res1 = 0 ;
16510 bool temp2 = false ;
16511 PyObject * obj0 = 0 ;
16512 PyObject * obj1 = 0 ;
16513 char * kwnames[] = {
16514 (char *) "self",(char *) "name", NULL
16515 };
16516
16517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16519 if (!SWIG_IsOK(res1)) {
16520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16521 }
16522 arg1 = reinterpret_cast< wxImage * >(argp1);
16523 {
16524 arg2 = wxString_in_helper(obj1);
16525 if (arg2 == NULL) SWIG_fail;
16526 temp2 = true;
16527 }
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 resultobj = SWIG_From_int(static_cast< int >(result));
16535 {
16536 if (temp2)
16537 delete arg2;
16538 }
16539 return resultobj;
16540 fail:
16541 {
16542 if (temp2)
16543 delete arg2;
16544 }
16545 return NULL;
16546 }
16547
16548
16549 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16550 PyObject *resultobj = 0;
16551 wxImage *arg1 = (wxImage *) 0 ;
16552 wxString *arg2 = 0 ;
16553 bool result;
16554 void *argp1 = 0 ;
16555 int res1 = 0 ;
16556 bool temp2 = false ;
16557 PyObject * obj0 = 0 ;
16558 PyObject * obj1 = 0 ;
16559 char * kwnames[] = {
16560 (char *) "self",(char *) "name", NULL
16561 };
16562
16563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16565 if (!SWIG_IsOK(res1)) {
16566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16567 }
16568 arg1 = reinterpret_cast< wxImage * >(argp1);
16569 {
16570 arg2 = wxString_in_helper(obj1);
16571 if (arg2 == NULL) SWIG_fail;
16572 temp2 = true;
16573 }
16574 {
16575 PyThreadState* __tstate = wxPyBeginAllowThreads();
16576 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16582 }
16583 {
16584 if (temp2)
16585 delete arg2;
16586 }
16587 return resultobj;
16588 fail:
16589 {
16590 if (temp2)
16591 delete arg2;
16592 }
16593 return NULL;
16594 }
16595
16596
16597 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj = 0;
16599 wxImage *arg1 = (wxImage *) 0 ;
16600 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16601 unsigned long result;
16602 void *argp1 = 0 ;
16603 int res1 = 0 ;
16604 unsigned long val2 ;
16605 int ecode2 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 char * kwnames[] = {
16609 (char *) "self",(char *) "stopafter", NULL
16610 };
16611
16612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16614 if (!SWIG_IsOK(res1)) {
16615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16616 }
16617 arg1 = reinterpret_cast< wxImage * >(argp1);
16618 if (obj1) {
16619 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16620 if (!SWIG_IsOK(ecode2)) {
16621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16622 }
16623 arg2 = static_cast< unsigned long >(val2);
16624 }
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 result = (unsigned long)(arg1)->CountColours(arg2);
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16632 return resultobj;
16633 fail:
16634 return NULL;
16635 }
16636
16637
16638 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16639 PyObject *resultobj = 0;
16640 wxImage *arg1 = (wxImage *) 0 ;
16641 wxImageHistogram *arg2 = 0 ;
16642 unsigned long result;
16643 void *argp1 = 0 ;
16644 int res1 = 0 ;
16645 void *argp2 = 0 ;
16646 int res2 = 0 ;
16647 PyObject * obj0 = 0 ;
16648 PyObject * obj1 = 0 ;
16649 char * kwnames[] = {
16650 (char *) "self",(char *) "h", NULL
16651 };
16652
16653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16655 if (!SWIG_IsOK(res1)) {
16656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16657 }
16658 arg1 = reinterpret_cast< wxImage * >(argp1);
16659 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16660 if (!SWIG_IsOK(res2)) {
16661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16662 }
16663 if (!argp2) {
16664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16665 }
16666 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj = 0;
16682 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16683 void *argp1 = 0 ;
16684 int res1 = 0 ;
16685 PyObject * obj0 = 0 ;
16686 char * kwnames[] = {
16687 (char *) "handler", NULL
16688 };
16689
16690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16692 if (!SWIG_IsOK(res1)) {
16693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16694 }
16695 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 wxImage::AddHandler(arg1);
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_Py_Void();
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj = 0;
16711 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16712 void *argp1 = 0 ;
16713 int res1 = 0 ;
16714 PyObject * obj0 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "handler", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16723 }
16724 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16725 {
16726 PyThreadState* __tstate = wxPyBeginAllowThreads();
16727 wxImage::InsertHandler(arg1);
16728 wxPyEndAllowThreads(__tstate);
16729 if (PyErr_Occurred()) SWIG_fail;
16730 }
16731 resultobj = SWIG_Py_Void();
16732 return resultobj;
16733 fail:
16734 return NULL;
16735 }
16736
16737
16738 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj = 0;
16740 wxString *arg1 = 0 ;
16741 bool result;
16742 bool temp1 = false ;
16743 PyObject * obj0 = 0 ;
16744 char * kwnames[] = {
16745 (char *) "name", NULL
16746 };
16747
16748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16749 {
16750 arg1 = wxString_in_helper(obj0);
16751 if (arg1 == NULL) SWIG_fail;
16752 temp1 = true;
16753 }
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 {
16761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16762 }
16763 {
16764 if (temp1)
16765 delete arg1;
16766 }
16767 return resultobj;
16768 fail:
16769 {
16770 if (temp1)
16771 delete arg1;
16772 }
16773 return NULL;
16774 }
16775
16776
16777 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16778 PyObject *resultobj = 0;
16779 PyObject *result = 0 ;
16780
16781 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16782 {
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 result = (PyObject *)wxImage_GetHandlers();
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = result;
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16796 PyObject *resultobj = 0;
16797 wxString result;
16798
16799 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16800 {
16801 PyThreadState* __tstate = wxPyBeginAllowThreads();
16802 result = wxImage::GetImageExtWildcard();
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 {
16807 #if wxUSE_UNICODE
16808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16809 #else
16810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16811 #endif
16812 }
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxImage *arg1 = (wxImage *) 0 ;
16822 int arg2 = (int) -1 ;
16823 wxBitmap result;
16824 void *argp1 = 0 ;
16825 int res1 = 0 ;
16826 int val2 ;
16827 int ecode2 = 0 ;
16828 PyObject * obj0 = 0 ;
16829 PyObject * obj1 = 0 ;
16830 char * kwnames[] = {
16831 (char *) "self",(char *) "depth", NULL
16832 };
16833
16834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16836 if (!SWIG_IsOK(res1)) {
16837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16838 }
16839 arg1 = reinterpret_cast< wxImage * >(argp1);
16840 if (obj1) {
16841 ecode2 = SWIG_AsVal_int(obj1, &val2);
16842 if (!SWIG_IsOK(ecode2)) {
16843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16844 }
16845 arg2 = static_cast< int >(val2);
16846 }
16847 {
16848 if (!wxPyCheckForApp()) SWIG_fail;
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = wxImage_ConvertToBitmap(arg1,arg2);
16851 wxPyEndAllowThreads(__tstate);
16852 if (PyErr_Occurred()) SWIG_fail;
16853 }
16854 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16862 PyObject *resultobj = 0;
16863 wxImage *arg1 = (wxImage *) 0 ;
16864 byte arg2 ;
16865 byte arg3 ;
16866 byte arg4 ;
16867 wxBitmap result;
16868 void *argp1 = 0 ;
16869 int res1 = 0 ;
16870 unsigned char val2 ;
16871 int ecode2 = 0 ;
16872 unsigned char val3 ;
16873 int ecode3 = 0 ;
16874 unsigned char val4 ;
16875 int ecode4 = 0 ;
16876 PyObject * obj0 = 0 ;
16877 PyObject * obj1 = 0 ;
16878 PyObject * obj2 = 0 ;
16879 PyObject * obj3 = 0 ;
16880 char * kwnames[] = {
16881 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16882 };
16883
16884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16886 if (!SWIG_IsOK(res1)) {
16887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16888 }
16889 arg1 = reinterpret_cast< wxImage * >(argp1);
16890 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16891 if (!SWIG_IsOK(ecode2)) {
16892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16893 }
16894 arg2 = static_cast< byte >(val2);
16895 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16896 if (!SWIG_IsOK(ecode3)) {
16897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16898 }
16899 arg3 = static_cast< byte >(val3);
16900 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16901 if (!SWIG_IsOK(ecode4)) {
16902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16903 }
16904 arg4 = static_cast< byte >(val4);
16905 {
16906 if (!wxPyCheckForApp()) SWIG_fail;
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16920 PyObject *resultobj = 0;
16921 wxImage *arg1 = (wxImage *) 0 ;
16922 double arg2 ;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 double val2 ;
16926 int ecode2 = 0 ;
16927 PyObject * obj0 = 0 ;
16928 PyObject * obj1 = 0 ;
16929 char * kwnames[] = {
16930 (char *) "self",(char *) "angle", NULL
16931 };
16932
16933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16935 if (!SWIG_IsOK(res1)) {
16936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16937 }
16938 arg1 = reinterpret_cast< wxImage * >(argp1);
16939 ecode2 = SWIG_AsVal_double(obj1, &val2);
16940 if (!SWIG_IsOK(ecode2)) {
16941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16942 }
16943 arg2 = static_cast< double >(val2);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 (arg1)->RotateHue(arg2);
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 resultobj = SWIG_Py_Void();
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj = 0;
16959 wxImage_RGBValue arg1 ;
16960 wxImage_HSVValue result;
16961 void *argp1 ;
16962 int res1 = 0 ;
16963 PyObject * obj0 = 0 ;
16964 char * kwnames[] = {
16965 (char *) "rgb", NULL
16966 };
16967
16968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16969 {
16970 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16971 if (!SWIG_IsOK(res1)) {
16972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16973 }
16974 if (!argp1) {
16975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16976 } else {
16977 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16978 arg1 = *temp;
16979 if (SWIG_IsNewObj(res1)) delete temp;
16980 }
16981 }
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 result = wxImage::RGBtoHSV(arg1);
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16989 return resultobj;
16990 fail:
16991 return NULL;
16992 }
16993
16994
16995 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16996 PyObject *resultobj = 0;
16997 wxImage_HSVValue arg1 ;
16998 wxImage_RGBValue result;
16999 void *argp1 ;
17000 int res1 = 0 ;
17001 PyObject * obj0 = 0 ;
17002 char * kwnames[] = {
17003 (char *) "hsv", NULL
17004 };
17005
17006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17007 {
17008 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17009 if (!SWIG_IsOK(res1)) {
17010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17011 }
17012 if (!argp1) {
17013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17014 } else {
17015 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17016 arg1 = *temp;
17017 if (SWIG_IsNewObj(res1)) delete temp;
17018 }
17019 }
17020 {
17021 PyThreadState* __tstate = wxPyBeginAllowThreads();
17022 result = wxImage::HSVtoRGB(arg1);
17023 wxPyEndAllowThreads(__tstate);
17024 if (PyErr_Occurred()) SWIG_fail;
17025 }
17026 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17027 return resultobj;
17028 fail:
17029 return NULL;
17030 }
17031
17032
17033 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17034 PyObject *obj;
17035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17036 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17037 return SWIG_Py_Void();
17038 }
17039
17040 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17041 return SWIG_Python_InitShadowInstance(args);
17042 }
17043
17044 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17045 PyObject *resultobj = 0;
17046 int arg1 ;
17047 int arg2 ;
17048 buffer arg3 ;
17049 int arg4 ;
17050 buffer arg5 = (buffer) NULL ;
17051 int arg6 = (int) 0 ;
17052 wxImage *result = 0 ;
17053 int val1 ;
17054 int ecode1 = 0 ;
17055 int val2 ;
17056 int ecode2 = 0 ;
17057 PyObject * obj0 = 0 ;
17058 PyObject * obj1 = 0 ;
17059 PyObject * obj2 = 0 ;
17060 PyObject * obj3 = 0 ;
17061 char * kwnames[] = {
17062 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17063 };
17064
17065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17066 ecode1 = SWIG_AsVal_int(obj0, &val1);
17067 if (!SWIG_IsOK(ecode1)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17069 }
17070 arg1 = static_cast< int >(val1);
17071 ecode2 = SWIG_AsVal_int(obj1, &val2);
17072 if (!SWIG_IsOK(ecode2)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17074 }
17075 arg2 = static_cast< int >(val2);
17076 {
17077 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
17078 }
17079 if (obj3) {
17080 {
17081 if (obj3 != Py_None) {
17082 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &arg6) == -1) SWIG_fail;
17083 }
17084 }
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 {
17093 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17094 }
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 SWIGINTERN int NullImage_set(PyObject *) {
17102 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17103 return 1;
17104 }
17105
17106
17107 SWIGINTERN PyObject *NullImage_get(void) {
17108 PyObject *pyobj = 0;
17109
17110 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17111 return pyobj;
17112 }
17113
17114
17115 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17116 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17117 return 1;
17118 }
17119
17120
17121 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17122 PyObject *pyobj = 0;
17123
17124 {
17125 #if wxUSE_UNICODE
17126 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17127 #else
17128 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17129 #endif
17130 }
17131 return pyobj;
17132 }
17133
17134
17135 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17136 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17137 return 1;
17138 }
17139
17140
17141 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17142 PyObject *pyobj = 0;
17143
17144 {
17145 #if wxUSE_UNICODE
17146 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17147 #else
17148 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17149 #endif
17150 }
17151 return pyobj;
17152 }
17153
17154
17155 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17156 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17157 return 1;
17158 }
17159
17160
17161 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17162 PyObject *pyobj = 0;
17163
17164 {
17165 #if wxUSE_UNICODE
17166 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17167 #else
17168 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17169 #endif
17170 }
17171 return pyobj;
17172 }
17173
17174
17175 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17176 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17177 return 1;
17178 }
17179
17180
17181 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17182 PyObject *pyobj = 0;
17183
17184 {
17185 #if wxUSE_UNICODE
17186 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17187 #else
17188 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17189 #endif
17190 }
17191 return pyobj;
17192 }
17193
17194
17195 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17196 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17197 return 1;
17198 }
17199
17200
17201 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17202 PyObject *pyobj = 0;
17203
17204 {
17205 #if wxUSE_UNICODE
17206 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17207 #else
17208 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17209 #endif
17210 }
17211 return pyobj;
17212 }
17213
17214
17215 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17216 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17217 return 1;
17218 }
17219
17220
17221 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17222 PyObject *pyobj = 0;
17223
17224 {
17225 #if wxUSE_UNICODE
17226 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17227 #else
17228 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17229 #endif
17230 }
17231 return pyobj;
17232 }
17233
17234
17235 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17236 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17237 return 1;
17238 }
17239
17240
17241 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17242 PyObject *pyobj = 0;
17243
17244 {
17245 #if wxUSE_UNICODE
17246 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17247 #else
17248 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17249 #endif
17250 }
17251 return pyobj;
17252 }
17253
17254
17255 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17256 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17257 return 1;
17258 }
17259
17260
17261 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17262 PyObject *pyobj = 0;
17263
17264 {
17265 #if wxUSE_UNICODE
17266 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17267 #else
17268 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17269 #endif
17270 }
17271 return pyobj;
17272 }
17273
17274
17275 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17276 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17277 return 1;
17278 }
17279
17280
17281 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17282 PyObject *pyobj = 0;
17283
17284 {
17285 #if wxUSE_UNICODE
17286 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17287 #else
17288 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17289 #endif
17290 }
17291 return pyobj;
17292 }
17293
17294
17295 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17296 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17297 return 1;
17298 }
17299
17300
17301 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17302 PyObject *pyobj = 0;
17303
17304 {
17305 #if wxUSE_UNICODE
17306 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17307 #else
17308 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17309 #endif
17310 }
17311 return pyobj;
17312 }
17313
17314
17315 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17316 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17317 return 1;
17318 }
17319
17320
17321 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17322 PyObject *pyobj = 0;
17323
17324 {
17325 #if wxUSE_UNICODE
17326 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17327 #else
17328 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17329 #endif
17330 }
17331 return pyobj;
17332 }
17333
17334
17335 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17336 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17337 return 1;
17338 }
17339
17340
17341 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17342 PyObject *pyobj = 0;
17343
17344 {
17345 #if wxUSE_UNICODE
17346 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17347 #else
17348 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17349 #endif
17350 }
17351 return pyobj;
17352 }
17353
17354
17355 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17356 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17357 return 1;
17358 }
17359
17360
17361 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17362 PyObject *pyobj = 0;
17363
17364 {
17365 #if wxUSE_UNICODE
17366 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17367 #else
17368 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17369 #endif
17370 }
17371 return pyobj;
17372 }
17373
17374
17375 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17376 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17377 return 1;
17378 }
17379
17380
17381 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17382 PyObject *pyobj = 0;
17383
17384 {
17385 #if wxUSE_UNICODE
17386 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17387 #else
17388 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17389 #endif
17390 }
17391 return pyobj;
17392 }
17393
17394
17395 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17396 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17397 return 1;
17398 }
17399
17400
17401 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17402 PyObject *pyobj = 0;
17403
17404 {
17405 #if wxUSE_UNICODE
17406 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17407 #else
17408 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17409 #endif
17410 }
17411 return pyobj;
17412 }
17413
17414
17415 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416 PyObject *resultobj = 0;
17417 wxBMPHandler *result = 0 ;
17418
17419 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (wxBMPHandler *)new wxBMPHandler();
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17427 return resultobj;
17428 fail:
17429 return NULL;
17430 }
17431
17432
17433 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *obj;
17435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17436 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17437 return SWIG_Py_Void();
17438 }
17439
17440 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17441 return SWIG_Python_InitShadowInstance(args);
17442 }
17443
17444 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 PyObject *resultobj = 0;
17446 wxICOHandler *result = 0 ;
17447
17448 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17449 {
17450 PyThreadState* __tstate = wxPyBeginAllowThreads();
17451 result = (wxICOHandler *)new wxICOHandler();
17452 wxPyEndAllowThreads(__tstate);
17453 if (PyErr_Occurred()) SWIG_fail;
17454 }
17455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17456 return resultobj;
17457 fail:
17458 return NULL;
17459 }
17460
17461
17462 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *obj;
17464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17465 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17466 return SWIG_Py_Void();
17467 }
17468
17469 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 return SWIG_Python_InitShadowInstance(args);
17471 }
17472
17473 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17474 PyObject *resultobj = 0;
17475 wxCURHandler *result = 0 ;
17476
17477 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17478 {
17479 PyThreadState* __tstate = wxPyBeginAllowThreads();
17480 result = (wxCURHandler *)new wxCURHandler();
17481 wxPyEndAllowThreads(__tstate);
17482 if (PyErr_Occurred()) SWIG_fail;
17483 }
17484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17485 return resultobj;
17486 fail:
17487 return NULL;
17488 }
17489
17490
17491 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *obj;
17493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17494 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17495 return SWIG_Py_Void();
17496 }
17497
17498 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17499 return SWIG_Python_InitShadowInstance(args);
17500 }
17501
17502 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17503 PyObject *resultobj = 0;
17504 wxANIHandler *result = 0 ;
17505
17506 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (wxANIHandler *)new wxANIHandler();
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17514 return resultobj;
17515 fail:
17516 return NULL;
17517 }
17518
17519
17520 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *obj;
17522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17523 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17524 return SWIG_Py_Void();
17525 }
17526
17527 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 return SWIG_Python_InitShadowInstance(args);
17529 }
17530
17531 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxPNGHandler *result = 0 ;
17534
17535 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (wxPNGHandler *)new wxPNGHandler();
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17550 PyObject *obj;
17551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17552 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17553 return SWIG_Py_Void();
17554 }
17555
17556 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17557 return SWIG_Python_InitShadowInstance(args);
17558 }
17559
17560 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17561 PyObject *resultobj = 0;
17562 wxGIFHandler *result = 0 ;
17563
17564 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17565 {
17566 PyThreadState* __tstate = wxPyBeginAllowThreads();
17567 result = (wxGIFHandler *)new wxGIFHandler();
17568 wxPyEndAllowThreads(__tstate);
17569 if (PyErr_Occurred()) SWIG_fail;
17570 }
17571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17572 return resultobj;
17573 fail:
17574 return NULL;
17575 }
17576
17577
17578 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17579 PyObject *obj;
17580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17581 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17582 return SWIG_Py_Void();
17583 }
17584
17585 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17586 return SWIG_Python_InitShadowInstance(args);
17587 }
17588
17589 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17590 PyObject *resultobj = 0;
17591 wxPCXHandler *result = 0 ;
17592
17593 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (wxPCXHandler *)new wxPCXHandler();
17597 wxPyEndAllowThreads(__tstate);
17598 if (PyErr_Occurred()) SWIG_fail;
17599 }
17600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17601 return resultobj;
17602 fail:
17603 return NULL;
17604 }
17605
17606
17607 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17608 PyObject *obj;
17609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17610 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17611 return SWIG_Py_Void();
17612 }
17613
17614 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17615 return SWIG_Python_InitShadowInstance(args);
17616 }
17617
17618 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17619 PyObject *resultobj = 0;
17620 wxJPEGHandler *result = 0 ;
17621
17622 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (wxJPEGHandler *)new wxJPEGHandler();
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17637 PyObject *obj;
17638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17639 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17640 return SWIG_Py_Void();
17641 }
17642
17643 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17644 return SWIG_Python_InitShadowInstance(args);
17645 }
17646
17647 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17648 PyObject *resultobj = 0;
17649 wxPNMHandler *result = 0 ;
17650
17651 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (wxPNMHandler *)new wxPNMHandler();
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17666 PyObject *obj;
17667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17668 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17669 return SWIG_Py_Void();
17670 }
17671
17672 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17673 return SWIG_Python_InitShadowInstance(args);
17674 }
17675
17676 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17677 PyObject *resultobj = 0;
17678 wxXPMHandler *result = 0 ;
17679
17680 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17681 {
17682 PyThreadState* __tstate = wxPyBeginAllowThreads();
17683 result = (wxXPMHandler *)new wxXPMHandler();
17684 wxPyEndAllowThreads(__tstate);
17685 if (PyErr_Occurred()) SWIG_fail;
17686 }
17687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17688 return resultobj;
17689 fail:
17690 return NULL;
17691 }
17692
17693
17694 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17695 PyObject *obj;
17696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17697 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17698 return SWIG_Py_Void();
17699 }
17700
17701 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17702 return SWIG_Python_InitShadowInstance(args);
17703 }
17704
17705 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17706 PyObject *resultobj = 0;
17707 wxTIFFHandler *result = 0 ;
17708
17709 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17710 {
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 result = (wxTIFFHandler *)new wxTIFFHandler();
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17724 PyObject *obj;
17725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17726 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17727 return SWIG_Py_Void();
17728 }
17729
17730 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17731 return SWIG_Python_InitShadowInstance(args);
17732 }
17733
17734 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17735 PyObject *resultobj = 0;
17736 wxImage *arg1 = 0 ;
17737 wxImage *arg2 = 0 ;
17738 int arg3 = (int) 236 ;
17739 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17740 bool result;
17741 void *argp1 = 0 ;
17742 int res1 = 0 ;
17743 void *argp2 = 0 ;
17744 int res2 = 0 ;
17745 int val3 ;
17746 int ecode3 = 0 ;
17747 int val4 ;
17748 int ecode4 = 0 ;
17749 PyObject * obj0 = 0 ;
17750 PyObject * obj1 = 0 ;
17751 PyObject * obj2 = 0 ;
17752 PyObject * obj3 = 0 ;
17753 char * kwnames[] = {
17754 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17755 };
17756
17757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17758 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17759 if (!SWIG_IsOK(res1)) {
17760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17761 }
17762 if (!argp1) {
17763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17764 }
17765 arg1 = reinterpret_cast< wxImage * >(argp1);
17766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17767 if (!SWIG_IsOK(res2)) {
17768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17769 }
17770 if (!argp2) {
17771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17772 }
17773 arg2 = reinterpret_cast< wxImage * >(argp2);
17774 if (obj2) {
17775 ecode3 = SWIG_AsVal_int(obj2, &val3);
17776 if (!SWIG_IsOK(ecode3)) {
17777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17778 }
17779 arg3 = static_cast< int >(val3);
17780 }
17781 if (obj3) {
17782 ecode4 = SWIG_AsVal_int(obj3, &val4);
17783 if (!SWIG_IsOK(ecode4)) {
17784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17785 }
17786 arg4 = static_cast< int >(val4);
17787 }
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 {
17795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17796 }
17797 return resultobj;
17798 fail:
17799 return NULL;
17800 }
17801
17802
17803 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17804 PyObject *obj;
17805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17806 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17807 return SWIG_Py_Void();
17808 }
17809
17810 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17811 PyObject *resultobj = 0;
17812 wxEvtHandler *result = 0 ;
17813
17814 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17815 {
17816 PyThreadState* __tstate = wxPyBeginAllowThreads();
17817 result = (wxEvtHandler *)new wxEvtHandler();
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17822 return resultobj;
17823 fail:
17824 return NULL;
17825 }
17826
17827
17828 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17829 PyObject *resultobj = 0;
17830 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17831 wxEvtHandler *result = 0 ;
17832 void *argp1 = 0 ;
17833 int res1 = 0 ;
17834 PyObject *swig_obj[1] ;
17835
17836 if (!args) SWIG_fail;
17837 swig_obj[0] = args;
17838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17839 if (!SWIG_IsOK(res1)) {
17840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17841 }
17842 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17843 {
17844 PyThreadState* __tstate = wxPyBeginAllowThreads();
17845 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 {
17850 resultobj = wxPyMake_wxObject(result, 0);
17851 }
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17859 PyObject *resultobj = 0;
17860 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17861 wxEvtHandler *result = 0 ;
17862 void *argp1 = 0 ;
17863 int res1 = 0 ;
17864 PyObject *swig_obj[1] ;
17865
17866 if (!args) SWIG_fail;
17867 swig_obj[0] = args;
17868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17869 if (!SWIG_IsOK(res1)) {
17870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17871 }
17872 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17873 {
17874 PyThreadState* __tstate = wxPyBeginAllowThreads();
17875 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 resultobj = wxPyMake_wxObject(result, 0);
17881 }
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj = 0;
17890 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17891 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17892 void *argp1 = 0 ;
17893 int res1 = 0 ;
17894 void *argp2 = 0 ;
17895 int res2 = 0 ;
17896 PyObject * obj0 = 0 ;
17897 PyObject * obj1 = 0 ;
17898 char * kwnames[] = {
17899 (char *) "self",(char *) "handler", NULL
17900 };
17901
17902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17904 if (!SWIG_IsOK(res1)) {
17905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17906 }
17907 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17909 if (!SWIG_IsOK(res2)) {
17910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17911 }
17912 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 (arg1)->SetNextHandler(arg2);
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 resultobj = SWIG_Py_Void();
17920 return resultobj;
17921 fail:
17922 return NULL;
17923 }
17924
17925
17926 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17927 PyObject *resultobj = 0;
17928 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17929 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17930 void *argp1 = 0 ;
17931 int res1 = 0 ;
17932 void *argp2 = 0 ;
17933 int res2 = 0 ;
17934 PyObject * obj0 = 0 ;
17935 PyObject * obj1 = 0 ;
17936 char * kwnames[] = {
17937 (char *) "self",(char *) "handler", NULL
17938 };
17939
17940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17944 }
17945 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17947 if (!SWIG_IsOK(res2)) {
17948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17949 }
17950 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 (arg1)->SetPreviousHandler(arg2);
17954 wxPyEndAllowThreads(__tstate);
17955 if (PyErr_Occurred()) SWIG_fail;
17956 }
17957 resultobj = SWIG_Py_Void();
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17965 PyObject *resultobj = 0;
17966 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17967 bool result;
17968 void *argp1 = 0 ;
17969 int res1 = 0 ;
17970 PyObject *swig_obj[1] ;
17971
17972 if (!args) SWIG_fail;
17973 swig_obj[0] = args;
17974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17975 if (!SWIG_IsOK(res1)) {
17976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17977 }
17978 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 result = (bool)(arg1)->GetEvtHandlerEnabled();
17982 wxPyEndAllowThreads(__tstate);
17983 if (PyErr_Occurred()) SWIG_fail;
17984 }
17985 {
17986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17987 }
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17995 PyObject *resultobj = 0;
17996 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17997 bool arg2 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 bool val2 ;
18001 int ecode2 = 0 ;
18002 PyObject * obj0 = 0 ;
18003 PyObject * obj1 = 0 ;
18004 char * kwnames[] = {
18005 (char *) "self",(char *) "enabled", NULL
18006 };
18007
18008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18010 if (!SWIG_IsOK(res1)) {
18011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18012 }
18013 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18014 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18015 if (!SWIG_IsOK(ecode2)) {
18016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18017 }
18018 arg2 = static_cast< bool >(val2);
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 (arg1)->SetEvtHandlerEnabled(arg2);
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 resultobj = SWIG_Py_Void();
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = 0;
18034 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18035 wxEvent *arg2 = 0 ;
18036 bool result;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 void *argp2 = 0 ;
18040 int res2 = 0 ;
18041 PyObject * obj0 = 0 ;
18042 PyObject * obj1 = 0 ;
18043 char * kwnames[] = {
18044 (char *) "self",(char *) "event", NULL
18045 };
18046
18047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18049 if (!SWIG_IsOK(res1)) {
18050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18051 }
18052 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18054 if (!SWIG_IsOK(res2)) {
18055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18056 }
18057 if (!argp2) {
18058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18059 }
18060 arg2 = reinterpret_cast< wxEvent * >(argp2);
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = (bool)(arg1)->ProcessEvent(*arg2);
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 {
18068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18069 }
18070 return resultobj;
18071 fail:
18072 return NULL;
18073 }
18074
18075
18076 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18077 PyObject *resultobj = 0;
18078 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18079 wxEvent *arg2 = 0 ;
18080 void *argp1 = 0 ;
18081 int res1 = 0 ;
18082 void *argp2 = 0 ;
18083 int res2 = 0 ;
18084 PyObject * obj0 = 0 ;
18085 PyObject * obj1 = 0 ;
18086 char * kwnames[] = {
18087 (char *) "self",(char *) "event", NULL
18088 };
18089
18090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18092 if (!SWIG_IsOK(res1)) {
18093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18094 }
18095 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18097 if (!SWIG_IsOK(res2)) {
18098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18099 }
18100 if (!argp2) {
18101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18102 }
18103 arg2 = reinterpret_cast< wxEvent * >(argp2);
18104 {
18105 PyThreadState* __tstate = wxPyBeginAllowThreads();
18106 (arg1)->AddPendingEvent(*arg2);
18107 wxPyEndAllowThreads(__tstate);
18108 if (PyErr_Occurred()) SWIG_fail;
18109 }
18110 resultobj = SWIG_Py_Void();
18111 return resultobj;
18112 fail:
18113 return NULL;
18114 }
18115
18116
18117 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18118 PyObject *resultobj = 0;
18119 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18120 void *argp1 = 0 ;
18121 int res1 = 0 ;
18122 PyObject *swig_obj[1] ;
18123
18124 if (!args) SWIG_fail;
18125 swig_obj[0] = args;
18126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18127 if (!SWIG_IsOK(res1)) {
18128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18129 }
18130 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 (arg1)->ProcessPendingEvents();
18134 wxPyEndAllowThreads(__tstate);
18135 if (PyErr_Occurred()) SWIG_fail;
18136 }
18137 resultobj = SWIG_Py_Void();
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj = 0;
18146 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18147 int arg2 ;
18148 int arg3 ;
18149 int arg4 ;
18150 PyObject *arg5 = (PyObject *) 0 ;
18151 void *argp1 = 0 ;
18152 int res1 = 0 ;
18153 int val2 ;
18154 int ecode2 = 0 ;
18155 int val3 ;
18156 int ecode3 = 0 ;
18157 int val4 ;
18158 int ecode4 = 0 ;
18159 PyObject * obj0 = 0 ;
18160 PyObject * obj1 = 0 ;
18161 PyObject * obj2 = 0 ;
18162 PyObject * obj3 = 0 ;
18163 PyObject * obj4 = 0 ;
18164 char * kwnames[] = {
18165 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18166 };
18167
18168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18170 if (!SWIG_IsOK(res1)) {
18171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18172 }
18173 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18174 ecode2 = SWIG_AsVal_int(obj1, &val2);
18175 if (!SWIG_IsOK(ecode2)) {
18176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18177 }
18178 arg2 = static_cast< int >(val2);
18179 ecode3 = SWIG_AsVal_int(obj2, &val3);
18180 if (!SWIG_IsOK(ecode3)) {
18181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18182 }
18183 arg3 = static_cast< int >(val3);
18184 ecode4 = SWIG_AsVal_int(obj3, &val4);
18185 if (!SWIG_IsOK(ecode4)) {
18186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18187 }
18188 arg4 = static_cast< int >(val4);
18189 arg5 = obj4;
18190 {
18191 PyThreadState* __tstate = wxPyBeginAllowThreads();
18192 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 resultobj = SWIG_Py_Void();
18197 return resultobj;
18198 fail:
18199 return NULL;
18200 }
18201
18202
18203 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18204 PyObject *resultobj = 0;
18205 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18206 int arg2 ;
18207 int arg3 = (int) -1 ;
18208 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18209 bool result;
18210 void *argp1 = 0 ;
18211 int res1 = 0 ;
18212 int val2 ;
18213 int ecode2 = 0 ;
18214 int val3 ;
18215 int ecode3 = 0 ;
18216 int val4 ;
18217 int ecode4 = 0 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 PyObject * obj2 = 0 ;
18221 PyObject * obj3 = 0 ;
18222 char * kwnames[] = {
18223 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18224 };
18225
18226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18230 }
18231 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18232 ecode2 = SWIG_AsVal_int(obj1, &val2);
18233 if (!SWIG_IsOK(ecode2)) {
18234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18235 }
18236 arg2 = static_cast< int >(val2);
18237 if (obj2) {
18238 ecode3 = SWIG_AsVal_int(obj2, &val3);
18239 if (!SWIG_IsOK(ecode3)) {
18240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18241 }
18242 arg3 = static_cast< int >(val3);
18243 }
18244 if (obj3) {
18245 ecode4 = SWIG_AsVal_int(obj3, &val4);
18246 if (!SWIG_IsOK(ecode4)) {
18247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18248 }
18249 arg4 = static_cast< wxEventType >(val4);
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 {
18258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18259 }
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj = 0;
18268 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18269 PyObject *arg2 = (PyObject *) 0 ;
18270 bool arg3 = (bool) true ;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 bool val3 ;
18274 int ecode3 = 0 ;
18275 PyObject * obj0 = 0 ;
18276 PyObject * obj1 = 0 ;
18277 PyObject * obj2 = 0 ;
18278 char * kwnames[] = {
18279 (char *) "self",(char *) "_self",(char *) "incref", NULL
18280 };
18281
18282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18284 if (!SWIG_IsOK(res1)) {
18285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18286 }
18287 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18288 arg2 = obj1;
18289 if (obj2) {
18290 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18291 if (!SWIG_IsOK(ecode3)) {
18292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18293 }
18294 arg3 = static_cast< bool >(val3);
18295 }
18296 {
18297 PyThreadState* __tstate = wxPyBeginAllowThreads();
18298 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18299 wxPyEndAllowThreads(__tstate);
18300 if (PyErr_Occurred()) SWIG_fail;
18301 }
18302 resultobj = SWIG_Py_Void();
18303 return resultobj;
18304 fail:
18305 return NULL;
18306 }
18307
18308
18309 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18310 PyObject *obj;
18311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18312 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18313 return SWIG_Py_Void();
18314 }
18315
18316 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18317 return SWIG_Python_InitShadowInstance(args);
18318 }
18319
18320 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18321 PyObject *resultobj = 0;
18322 wxEventType result;
18323
18324 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (wxEventType)wxNewEventType();
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 resultobj = SWIG_From_int(static_cast< int >(result));
18332 return resultobj;
18333 fail:
18334 return NULL;
18335 }
18336
18337
18338 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18339 PyObject *resultobj = 0;
18340 wxEvent *arg1 = (wxEvent *) 0 ;
18341 void *argp1 = 0 ;
18342 int res1 = 0 ;
18343 PyObject *swig_obj[1] ;
18344
18345 if (!args) SWIG_fail;
18346 swig_obj[0] = args;
18347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18348 if (!SWIG_IsOK(res1)) {
18349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18350 }
18351 arg1 = reinterpret_cast< wxEvent * >(argp1);
18352 {
18353 PyThreadState* __tstate = wxPyBeginAllowThreads();
18354 delete arg1;
18355
18356 wxPyEndAllowThreads(__tstate);
18357 if (PyErr_Occurred()) SWIG_fail;
18358 }
18359 resultobj = SWIG_Py_Void();
18360 return resultobj;
18361 fail:
18362 return NULL;
18363 }
18364
18365
18366 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18367 PyObject *resultobj = 0;
18368 wxEvent *arg1 = (wxEvent *) 0 ;
18369 wxEventType arg2 ;
18370 void *argp1 = 0 ;
18371 int res1 = 0 ;
18372 int val2 ;
18373 int ecode2 = 0 ;
18374 PyObject * obj0 = 0 ;
18375 PyObject * obj1 = 0 ;
18376 char * kwnames[] = {
18377 (char *) "self",(char *) "typ", NULL
18378 };
18379
18380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18382 if (!SWIG_IsOK(res1)) {
18383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18384 }
18385 arg1 = reinterpret_cast< wxEvent * >(argp1);
18386 ecode2 = SWIG_AsVal_int(obj1, &val2);
18387 if (!SWIG_IsOK(ecode2)) {
18388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18389 }
18390 arg2 = static_cast< wxEventType >(val2);
18391 {
18392 PyThreadState* __tstate = wxPyBeginAllowThreads();
18393 (arg1)->SetEventType(arg2);
18394 wxPyEndAllowThreads(__tstate);
18395 if (PyErr_Occurred()) SWIG_fail;
18396 }
18397 resultobj = SWIG_Py_Void();
18398 return resultobj;
18399 fail:
18400 return NULL;
18401 }
18402
18403
18404 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18405 PyObject *resultobj = 0;
18406 wxEvent *arg1 = (wxEvent *) 0 ;
18407 wxEventType result;
18408 void *argp1 = 0 ;
18409 int res1 = 0 ;
18410 PyObject *swig_obj[1] ;
18411
18412 if (!args) SWIG_fail;
18413 swig_obj[0] = args;
18414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18417 }
18418 arg1 = reinterpret_cast< wxEvent * >(argp1);
18419 {
18420 PyThreadState* __tstate = wxPyBeginAllowThreads();
18421 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 resultobj = SWIG_From_int(static_cast< int >(result));
18426 return resultobj;
18427 fail:
18428 return NULL;
18429 }
18430
18431
18432 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18433 PyObject *resultobj = 0;
18434 wxEvent *arg1 = (wxEvent *) 0 ;
18435 wxObject *result = 0 ;
18436 void *argp1 = 0 ;
18437 int res1 = 0 ;
18438 PyObject *swig_obj[1] ;
18439
18440 if (!args) SWIG_fail;
18441 swig_obj[0] = args;
18442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18443 if (!SWIG_IsOK(res1)) {
18444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18445 }
18446 arg1 = reinterpret_cast< wxEvent * >(argp1);
18447 {
18448 PyThreadState* __tstate = wxPyBeginAllowThreads();
18449 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18450 wxPyEndAllowThreads(__tstate);
18451 if (PyErr_Occurred()) SWIG_fail;
18452 }
18453 {
18454 resultobj = wxPyMake_wxObject(result, (bool)0);
18455 }
18456 return resultobj;
18457 fail:
18458 return NULL;
18459 }
18460
18461
18462 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18463 PyObject *resultobj = 0;
18464 wxEvent *arg1 = (wxEvent *) 0 ;
18465 wxObject *arg2 = (wxObject *) 0 ;
18466 void *argp1 = 0 ;
18467 int res1 = 0 ;
18468 void *argp2 = 0 ;
18469 int res2 = 0 ;
18470 PyObject * obj0 = 0 ;
18471 PyObject * obj1 = 0 ;
18472 char * kwnames[] = {
18473 (char *) "self",(char *) "obj", NULL
18474 };
18475
18476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18478 if (!SWIG_IsOK(res1)) {
18479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18480 }
18481 arg1 = reinterpret_cast< wxEvent * >(argp1);
18482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18483 if (!SWIG_IsOK(res2)) {
18484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18485 }
18486 arg2 = reinterpret_cast< wxObject * >(argp2);
18487 {
18488 PyThreadState* __tstate = wxPyBeginAllowThreads();
18489 (arg1)->SetEventObject(arg2);
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 resultobj = SWIG_Py_Void();
18494 return resultobj;
18495 fail:
18496 return NULL;
18497 }
18498
18499
18500 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18501 PyObject *resultobj = 0;
18502 wxEvent *arg1 = (wxEvent *) 0 ;
18503 long result;
18504 void *argp1 = 0 ;
18505 int res1 = 0 ;
18506 PyObject *swig_obj[1] ;
18507
18508 if (!args) SWIG_fail;
18509 swig_obj[0] = args;
18510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18511 if (!SWIG_IsOK(res1)) {
18512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18513 }
18514 arg1 = reinterpret_cast< wxEvent * >(argp1);
18515 {
18516 PyThreadState* __tstate = wxPyBeginAllowThreads();
18517 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 resultobj = SWIG_From_long(static_cast< long >(result));
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18529 PyObject *resultobj = 0;
18530 wxEvent *arg1 = (wxEvent *) 0 ;
18531 long arg2 = (long) 0 ;
18532 void *argp1 = 0 ;
18533 int res1 = 0 ;
18534 long val2 ;
18535 int ecode2 = 0 ;
18536 PyObject * obj0 = 0 ;
18537 PyObject * obj1 = 0 ;
18538 char * kwnames[] = {
18539 (char *) "self",(char *) "ts", NULL
18540 };
18541
18542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18544 if (!SWIG_IsOK(res1)) {
18545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18546 }
18547 arg1 = reinterpret_cast< wxEvent * >(argp1);
18548 if (obj1) {
18549 ecode2 = SWIG_AsVal_long(obj1, &val2);
18550 if (!SWIG_IsOK(ecode2)) {
18551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18552 }
18553 arg2 = static_cast< long >(val2);
18554 }
18555 {
18556 PyThreadState* __tstate = wxPyBeginAllowThreads();
18557 (arg1)->SetTimestamp(arg2);
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 resultobj = SWIG_Py_Void();
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18569 PyObject *resultobj = 0;
18570 wxEvent *arg1 = (wxEvent *) 0 ;
18571 int result;
18572 void *argp1 = 0 ;
18573 int res1 = 0 ;
18574 PyObject *swig_obj[1] ;
18575
18576 if (!args) SWIG_fail;
18577 swig_obj[0] = args;
18578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18579 if (!SWIG_IsOK(res1)) {
18580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18581 }
18582 arg1 = reinterpret_cast< wxEvent * >(argp1);
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 result = (int)((wxEvent const *)arg1)->GetId();
18586 wxPyEndAllowThreads(__tstate);
18587 if (PyErr_Occurred()) SWIG_fail;
18588 }
18589 resultobj = SWIG_From_int(static_cast< int >(result));
18590 return resultobj;
18591 fail:
18592 return NULL;
18593 }
18594
18595
18596 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18597 PyObject *resultobj = 0;
18598 wxEvent *arg1 = (wxEvent *) 0 ;
18599 int arg2 ;
18600 void *argp1 = 0 ;
18601 int res1 = 0 ;
18602 int val2 ;
18603 int ecode2 = 0 ;
18604 PyObject * obj0 = 0 ;
18605 PyObject * obj1 = 0 ;
18606 char * kwnames[] = {
18607 (char *) "self",(char *) "Id", NULL
18608 };
18609
18610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18612 if (!SWIG_IsOK(res1)) {
18613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18614 }
18615 arg1 = reinterpret_cast< wxEvent * >(argp1);
18616 ecode2 = SWIG_AsVal_int(obj1, &val2);
18617 if (!SWIG_IsOK(ecode2)) {
18618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18619 }
18620 arg2 = static_cast< int >(val2);
18621 {
18622 PyThreadState* __tstate = wxPyBeginAllowThreads();
18623 (arg1)->SetId(arg2);
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 resultobj = SWIG_Py_Void();
18628 return resultobj;
18629 fail:
18630 return NULL;
18631 }
18632
18633
18634 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18635 PyObject *resultobj = 0;
18636 wxEvent *arg1 = (wxEvent *) 0 ;
18637 bool result;
18638 void *argp1 = 0 ;
18639 int res1 = 0 ;
18640 PyObject *swig_obj[1] ;
18641
18642 if (!args) SWIG_fail;
18643 swig_obj[0] = args;
18644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18645 if (!SWIG_IsOK(res1)) {
18646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18647 }
18648 arg1 = reinterpret_cast< wxEvent * >(argp1);
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 {
18656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18657 }
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18665 PyObject *resultobj = 0;
18666 wxEvent *arg1 = (wxEvent *) 0 ;
18667 bool arg2 = (bool) true ;
18668 void *argp1 = 0 ;
18669 int res1 = 0 ;
18670 bool val2 ;
18671 int ecode2 = 0 ;
18672 PyObject * obj0 = 0 ;
18673 PyObject * obj1 = 0 ;
18674 char * kwnames[] = {
18675 (char *) "self",(char *) "skip", NULL
18676 };
18677
18678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18680 if (!SWIG_IsOK(res1)) {
18681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18682 }
18683 arg1 = reinterpret_cast< wxEvent * >(argp1);
18684 if (obj1) {
18685 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18686 if (!SWIG_IsOK(ecode2)) {
18687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18688 }
18689 arg2 = static_cast< bool >(val2);
18690 }
18691 {
18692 PyThreadState* __tstate = wxPyBeginAllowThreads();
18693 (arg1)->Skip(arg2);
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 resultobj = SWIG_Py_Void();
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18705 PyObject *resultobj = 0;
18706 wxEvent *arg1 = (wxEvent *) 0 ;
18707 bool result;
18708 void *argp1 = 0 ;
18709 int res1 = 0 ;
18710 PyObject *swig_obj[1] ;
18711
18712 if (!args) SWIG_fail;
18713 swig_obj[0] = args;
18714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18715 if (!SWIG_IsOK(res1)) {
18716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18717 }
18718 arg1 = reinterpret_cast< wxEvent * >(argp1);
18719 {
18720 PyThreadState* __tstate = wxPyBeginAllowThreads();
18721 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18722 wxPyEndAllowThreads(__tstate);
18723 if (PyErr_Occurred()) SWIG_fail;
18724 }
18725 {
18726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18727 }
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18735 PyObject *resultobj = 0;
18736 wxEvent *arg1 = (wxEvent *) 0 ;
18737 bool result;
18738 void *argp1 = 0 ;
18739 int res1 = 0 ;
18740 PyObject *swig_obj[1] ;
18741
18742 if (!args) SWIG_fail;
18743 swig_obj[0] = args;
18744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18745 if (!SWIG_IsOK(res1)) {
18746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18747 }
18748 arg1 = reinterpret_cast< wxEvent * >(argp1);
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18752 wxPyEndAllowThreads(__tstate);
18753 if (PyErr_Occurred()) SWIG_fail;
18754 }
18755 {
18756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18757 }
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 PyObject *resultobj = 0;
18766 wxEvent *arg1 = (wxEvent *) 0 ;
18767 int result;
18768 void *argp1 = 0 ;
18769 int res1 = 0 ;
18770 PyObject *swig_obj[1] ;
18771
18772 if (!args) SWIG_fail;
18773 swig_obj[0] = args;
18774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18775 if (!SWIG_IsOK(res1)) {
18776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18777 }
18778 arg1 = reinterpret_cast< wxEvent * >(argp1);
18779 {
18780 PyThreadState* __tstate = wxPyBeginAllowThreads();
18781 result = (int)(arg1)->StopPropagation();
18782 wxPyEndAllowThreads(__tstate);
18783 if (PyErr_Occurred()) SWIG_fail;
18784 }
18785 resultobj = SWIG_From_int(static_cast< int >(result));
18786 return resultobj;
18787 fail:
18788 return NULL;
18789 }
18790
18791
18792 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18793 PyObject *resultobj = 0;
18794 wxEvent *arg1 = (wxEvent *) 0 ;
18795 int arg2 ;
18796 void *argp1 = 0 ;
18797 int res1 = 0 ;
18798 int val2 ;
18799 int ecode2 = 0 ;
18800 PyObject * obj0 = 0 ;
18801 PyObject * obj1 = 0 ;
18802 char * kwnames[] = {
18803 (char *) "self",(char *) "propagationLevel", NULL
18804 };
18805
18806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18808 if (!SWIG_IsOK(res1)) {
18809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18810 }
18811 arg1 = reinterpret_cast< wxEvent * >(argp1);
18812 ecode2 = SWIG_AsVal_int(obj1, &val2);
18813 if (!SWIG_IsOK(ecode2)) {
18814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18815 }
18816 arg2 = static_cast< int >(val2);
18817 {
18818 PyThreadState* __tstate = wxPyBeginAllowThreads();
18819 (arg1)->ResumePropagation(arg2);
18820 wxPyEndAllowThreads(__tstate);
18821 if (PyErr_Occurred()) SWIG_fail;
18822 }
18823 resultobj = SWIG_Py_Void();
18824 return resultobj;
18825 fail:
18826 return NULL;
18827 }
18828
18829
18830 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18831 PyObject *resultobj = 0;
18832 wxEvent *arg1 = (wxEvent *) 0 ;
18833 wxEvent *result = 0 ;
18834 void *argp1 = 0 ;
18835 int res1 = 0 ;
18836 PyObject *swig_obj[1] ;
18837
18838 if (!args) SWIG_fail;
18839 swig_obj[0] = args;
18840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18841 if (!SWIG_IsOK(res1)) {
18842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18843 }
18844 arg1 = reinterpret_cast< wxEvent * >(argp1);
18845 {
18846 PyThreadState* __tstate = wxPyBeginAllowThreads();
18847 result = (wxEvent *)(arg1)->Clone();
18848 wxPyEndAllowThreads(__tstate);
18849 if (PyErr_Occurred()) SWIG_fail;
18850 }
18851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18852 return resultobj;
18853 fail:
18854 return NULL;
18855 }
18856
18857
18858 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18859 PyObject *obj;
18860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18861 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18862 return SWIG_Py_Void();
18863 }
18864
18865 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj = 0;
18867 wxEvent *arg1 = 0 ;
18868 wxPropagationDisabler *result = 0 ;
18869 void *argp1 = 0 ;
18870 int res1 = 0 ;
18871 PyObject * obj0 = 0 ;
18872 char * kwnames[] = {
18873 (char *) "event", NULL
18874 };
18875
18876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18877 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18880 }
18881 if (!argp1) {
18882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18883 }
18884 arg1 = reinterpret_cast< wxEvent * >(argp1);
18885 {
18886 PyThreadState* __tstate = wxPyBeginAllowThreads();
18887 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18899 PyObject *resultobj = 0;
18900 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18901 void *argp1 = 0 ;
18902 int res1 = 0 ;
18903 PyObject *swig_obj[1] ;
18904
18905 if (!args) SWIG_fail;
18906 swig_obj[0] = args;
18907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18908 if (!SWIG_IsOK(res1)) {
18909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18910 }
18911 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 delete arg1;
18915
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 resultobj = SWIG_Py_Void();
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18927 PyObject *obj;
18928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18929 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18930 return SWIG_Py_Void();
18931 }
18932
18933 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18934 return SWIG_Python_InitShadowInstance(args);
18935 }
18936
18937 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18938 PyObject *resultobj = 0;
18939 wxEvent *arg1 = 0 ;
18940 wxPropagateOnce *result = 0 ;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 PyObject * obj0 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "event", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18952 }
18953 if (!argp1) {
18954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18955 }
18956 arg1 = reinterpret_cast< wxEvent * >(argp1);
18957 {
18958 PyThreadState* __tstate = wxPyBeginAllowThreads();
18959 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18960 wxPyEndAllowThreads(__tstate);
18961 if (PyErr_Occurred()) SWIG_fail;
18962 }
18963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18971 PyObject *resultobj = 0;
18972 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18973 void *argp1 = 0 ;
18974 int res1 = 0 ;
18975 PyObject *swig_obj[1] ;
18976
18977 if (!args) SWIG_fail;
18978 swig_obj[0] = args;
18979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18980 if (!SWIG_IsOK(res1)) {
18981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18982 }
18983 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18984 {
18985 PyThreadState* __tstate = wxPyBeginAllowThreads();
18986 delete arg1;
18987
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 resultobj = SWIG_Py_Void();
18992 return resultobj;
18993 fail:
18994 return NULL;
18995 }
18996
18997
18998 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18999 PyObject *obj;
19000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19001 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19002 return SWIG_Py_Void();
19003 }
19004
19005 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19006 return SWIG_Python_InitShadowInstance(args);
19007 }
19008
19009 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19010 PyObject *resultobj = 0;
19011 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19012 int arg2 = (int) 0 ;
19013 wxCommandEvent *result = 0 ;
19014 int val1 ;
19015 int ecode1 = 0 ;
19016 int val2 ;
19017 int ecode2 = 0 ;
19018 PyObject * obj0 = 0 ;
19019 PyObject * obj1 = 0 ;
19020 char * kwnames[] = {
19021 (char *) "commandType",(char *) "winid", NULL
19022 };
19023
19024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19025 if (obj0) {
19026 ecode1 = SWIG_AsVal_int(obj0, &val1);
19027 if (!SWIG_IsOK(ecode1)) {
19028 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19029 }
19030 arg1 = static_cast< wxEventType >(val1);
19031 }
19032 if (obj1) {
19033 ecode2 = SWIG_AsVal_int(obj1, &val2);
19034 if (!SWIG_IsOK(ecode2)) {
19035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19036 }
19037 arg2 = static_cast< int >(val2);
19038 }
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 int result;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject *swig_obj[1] ;
19059
19060 if (!args) SWIG_fail;
19061 swig_obj[0] = args;
19062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19065 }
19066 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 resultobj = SWIG_From_int(static_cast< int >(result));
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj = 0;
19082 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19083 wxString *arg2 = 0 ;
19084 void *argp1 = 0 ;
19085 int res1 = 0 ;
19086 bool temp2 = false ;
19087 PyObject * obj0 = 0 ;
19088 PyObject * obj1 = 0 ;
19089 char * kwnames[] = {
19090 (char *) "self",(char *) "s", NULL
19091 };
19092
19093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19097 }
19098 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19099 {
19100 arg2 = wxString_in_helper(obj1);
19101 if (arg2 == NULL) SWIG_fail;
19102 temp2 = true;
19103 }
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 (arg1)->SetString((wxString const &)*arg2);
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 resultobj = SWIG_Py_Void();
19111 {
19112 if (temp2)
19113 delete arg2;
19114 }
19115 return resultobj;
19116 fail:
19117 {
19118 if (temp2)
19119 delete arg2;
19120 }
19121 return NULL;
19122 }
19123
19124
19125 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19126 PyObject *resultobj = 0;
19127 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19128 wxString result;
19129 void *argp1 = 0 ;
19130 int res1 = 0 ;
19131 PyObject *swig_obj[1] ;
19132
19133 if (!args) SWIG_fail;
19134 swig_obj[0] = args;
19135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19136 if (!SWIG_IsOK(res1)) {
19137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19138 }
19139 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 result = ((wxCommandEvent const *)arg1)->GetString();
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 {
19147 #if wxUSE_UNICODE
19148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19149 #else
19150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19151 #endif
19152 }
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19162 bool result;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19172 }
19173 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 {
19181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19182 }
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19190 PyObject *resultobj = 0;
19191 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19192 bool result;
19193 void *argp1 = 0 ;
19194 int res1 = 0 ;
19195 PyObject *swig_obj[1] ;
19196
19197 if (!args) SWIG_fail;
19198 swig_obj[0] = args;
19199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19200 if (!SWIG_IsOK(res1)) {
19201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19202 }
19203 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19207 wxPyEndAllowThreads(__tstate);
19208 if (PyErr_Occurred()) SWIG_fail;
19209 }
19210 {
19211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19212 }
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj = 0;
19221 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19222 long arg2 ;
19223 void *argp1 = 0 ;
19224 int res1 = 0 ;
19225 long val2 ;
19226 int ecode2 = 0 ;
19227 PyObject * obj0 = 0 ;
19228 PyObject * obj1 = 0 ;
19229 char * kwnames[] = {
19230 (char *) "self",(char *) "extraLong", NULL
19231 };
19232
19233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19235 if (!SWIG_IsOK(res1)) {
19236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19237 }
19238 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19239 ecode2 = SWIG_AsVal_long(obj1, &val2);
19240 if (!SWIG_IsOK(ecode2)) {
19241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19242 }
19243 arg2 = static_cast< long >(val2);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 (arg1)->SetExtraLong(arg2);
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = SWIG_Py_Void();
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 PyObject *resultobj = 0;
19259 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19260 long result;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 PyObject *swig_obj[1] ;
19264
19265 if (!args) SWIG_fail;
19266 swig_obj[0] = args;
19267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19268 if (!SWIG_IsOK(res1)) {
19269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19270 }
19271 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_From_long(static_cast< long >(result));
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj = 0;
19287 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19288 int arg2 ;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 int val2 ;
19292 int ecode2 = 0 ;
19293 PyObject * obj0 = 0 ;
19294 PyObject * obj1 = 0 ;
19295 char * kwnames[] = {
19296 (char *) "self",(char *) "i", NULL
19297 };
19298
19299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19303 }
19304 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19305 ecode2 = SWIG_AsVal_int(obj1, &val2);
19306 if (!SWIG_IsOK(ecode2)) {
19307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19308 }
19309 arg2 = static_cast< int >(val2);
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 (arg1)->SetInt(arg2);
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 resultobj = SWIG_Py_Void();
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19324 PyObject *resultobj = 0;
19325 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19326 int result;
19327 void *argp1 = 0 ;
19328 int res1 = 0 ;
19329 PyObject *swig_obj[1] ;
19330
19331 if (!args) SWIG_fail;
19332 swig_obj[0] = args;
19333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19334 if (!SWIG_IsOK(res1)) {
19335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19336 }
19337 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19338 {
19339 PyThreadState* __tstate = wxPyBeginAllowThreads();
19340 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19341 wxPyEndAllowThreads(__tstate);
19342 if (PyErr_Occurred()) SWIG_fail;
19343 }
19344 resultobj = SWIG_From_int(static_cast< int >(result));
19345 return resultobj;
19346 fail:
19347 return NULL;
19348 }
19349
19350
19351 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19352 PyObject *resultobj = 0;
19353 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19354 PyObject *result = 0 ;
19355 void *argp1 = 0 ;
19356 int res1 = 0 ;
19357 PyObject *swig_obj[1] ;
19358
19359 if (!args) SWIG_fail;
19360 swig_obj[0] = args;
19361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19362 if (!SWIG_IsOK(res1)) {
19363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19364 }
19365 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19366 {
19367 PyThreadState* __tstate = wxPyBeginAllowThreads();
19368 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19369 wxPyEndAllowThreads(__tstate);
19370 if (PyErr_Occurred()) SWIG_fail;
19371 }
19372 resultobj = result;
19373 return resultobj;
19374 fail:
19375 return NULL;
19376 }
19377
19378
19379 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19380 PyObject *resultobj = 0;
19381 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19382 PyObject *arg2 = (PyObject *) 0 ;
19383 void *argp1 = 0 ;
19384 int res1 = 0 ;
19385 PyObject * obj0 = 0 ;
19386 PyObject * obj1 = 0 ;
19387 char * kwnames[] = {
19388 (char *) "self",(char *) "clientData", NULL
19389 };
19390
19391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19393 if (!SWIG_IsOK(res1)) {
19394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19395 }
19396 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19397 arg2 = obj1;
19398 {
19399 PyThreadState* __tstate = wxPyBeginAllowThreads();
19400 wxCommandEvent_SetClientData(arg1,arg2);
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 resultobj = SWIG_Py_Void();
19405 return resultobj;
19406 fail:
19407 return NULL;
19408 }
19409
19410
19411 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19412 PyObject *resultobj = 0;
19413 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19414 wxEvent *result = 0 ;
19415 void *argp1 = 0 ;
19416 int res1 = 0 ;
19417 PyObject *swig_obj[1] ;
19418
19419 if (!args) SWIG_fail;
19420 swig_obj[0] = args;
19421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19422 if (!SWIG_IsOK(res1)) {
19423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19424 }
19425 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19426 {
19427 PyThreadState* __tstate = wxPyBeginAllowThreads();
19428 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19440 PyObject *obj;
19441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19442 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19443 return SWIG_Py_Void();
19444 }
19445
19446 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447 return SWIG_Python_InitShadowInstance(args);
19448 }
19449
19450 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19451 PyObject *resultobj = 0;
19452 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19453 int arg2 = (int) 0 ;
19454 wxNotifyEvent *result = 0 ;
19455 int val1 ;
19456 int ecode1 = 0 ;
19457 int val2 ;
19458 int ecode2 = 0 ;
19459 PyObject * obj0 = 0 ;
19460 PyObject * obj1 = 0 ;
19461 char * kwnames[] = {
19462 (char *) "commandType",(char *) "winid", NULL
19463 };
19464
19465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19466 if (obj0) {
19467 ecode1 = SWIG_AsVal_int(obj0, &val1);
19468 if (!SWIG_IsOK(ecode1)) {
19469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19470 }
19471 arg1 = static_cast< wxEventType >(val1);
19472 }
19473 if (obj1) {
19474 ecode2 = SWIG_AsVal_int(obj1, &val2);
19475 if (!SWIG_IsOK(ecode2)) {
19476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19477 }
19478 arg2 = static_cast< int >(val2);
19479 }
19480 {
19481 PyThreadState* __tstate = wxPyBeginAllowThreads();
19482 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19483 wxPyEndAllowThreads(__tstate);
19484 if (PyErr_Occurred()) SWIG_fail;
19485 }
19486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19494 PyObject *resultobj = 0;
19495 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19496 void *argp1 = 0 ;
19497 int res1 = 0 ;
19498 PyObject *swig_obj[1] ;
19499
19500 if (!args) SWIG_fail;
19501 swig_obj[0] = args;
19502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19503 if (!SWIG_IsOK(res1)) {
19504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19505 }
19506 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19507 {
19508 PyThreadState* __tstate = wxPyBeginAllowThreads();
19509 (arg1)->Veto();
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_Py_Void();
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19521 PyObject *resultobj = 0;
19522 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19523 void *argp1 = 0 ;
19524 int res1 = 0 ;
19525 PyObject *swig_obj[1] ;
19526
19527 if (!args) SWIG_fail;
19528 swig_obj[0] = args;
19529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19530 if (!SWIG_IsOK(res1)) {
19531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19532 }
19533 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19534 {
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 (arg1)->Allow();
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 resultobj = SWIG_Py_Void();
19541 return resultobj;
19542 fail:
19543 return NULL;
19544 }
19545
19546
19547 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19548 PyObject *resultobj = 0;
19549 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19550 bool result;
19551 void *argp1 = 0 ;
19552 int res1 = 0 ;
19553 PyObject *swig_obj[1] ;
19554
19555 if (!args) SWIG_fail;
19556 swig_obj[0] = args;
19557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19558 if (!SWIG_IsOK(res1)) {
19559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19560 }
19561 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = (bool)(arg1)->IsAllowed();
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 {
19569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19570 }
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19578 PyObject *obj;
19579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19580 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19581 return SWIG_Py_Void();
19582 }
19583
19584 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19585 return SWIG_Python_InitShadowInstance(args);
19586 }
19587
19588 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj = 0;
19590 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19591 int arg2 = (int) 0 ;
19592 int arg3 = (int) 0 ;
19593 int arg4 = (int) 0 ;
19594 wxScrollEvent *result = 0 ;
19595 int val1 ;
19596 int ecode1 = 0 ;
19597 int val2 ;
19598 int ecode2 = 0 ;
19599 int val3 ;
19600 int ecode3 = 0 ;
19601 int val4 ;
19602 int ecode4 = 0 ;
19603 PyObject * obj0 = 0 ;
19604 PyObject * obj1 = 0 ;
19605 PyObject * obj2 = 0 ;
19606 PyObject * obj3 = 0 ;
19607 char * kwnames[] = {
19608 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19609 };
19610
19611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19612 if (obj0) {
19613 ecode1 = SWIG_AsVal_int(obj0, &val1);
19614 if (!SWIG_IsOK(ecode1)) {
19615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19616 }
19617 arg1 = static_cast< wxEventType >(val1);
19618 }
19619 if (obj1) {
19620 ecode2 = SWIG_AsVal_int(obj1, &val2);
19621 if (!SWIG_IsOK(ecode2)) {
19622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19623 }
19624 arg2 = static_cast< int >(val2);
19625 }
19626 if (obj2) {
19627 ecode3 = SWIG_AsVal_int(obj2, &val3);
19628 if (!SWIG_IsOK(ecode3)) {
19629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19630 }
19631 arg3 = static_cast< int >(val3);
19632 }
19633 if (obj3) {
19634 ecode4 = SWIG_AsVal_int(obj3, &val4);
19635 if (!SWIG_IsOK(ecode4)) {
19636 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19637 }
19638 arg4 = static_cast< int >(val4);
19639 }
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654 PyObject *resultobj = 0;
19655 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19656 int result;
19657 void *argp1 = 0 ;
19658 int res1 = 0 ;
19659 PyObject *swig_obj[1] ;
19660
19661 if (!args) SWIG_fail;
19662 swig_obj[0] = args;
19663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19664 if (!SWIG_IsOK(res1)) {
19665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19666 }
19667 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 resultobj = SWIG_From_int(static_cast< int >(result));
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19682 PyObject *resultobj = 0;
19683 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19684 int result;
19685 void *argp1 = 0 ;
19686 int res1 = 0 ;
19687 PyObject *swig_obj[1] ;
19688
19689 if (!args) SWIG_fail;
19690 swig_obj[0] = args;
19691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19692 if (!SWIG_IsOK(res1)) {
19693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19694 }
19695 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19696 {
19697 PyThreadState* __tstate = wxPyBeginAllowThreads();
19698 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_From_int(static_cast< int >(result));
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19710 PyObject *resultobj = 0;
19711 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19712 int arg2 ;
19713 void *argp1 = 0 ;
19714 int res1 = 0 ;
19715 int val2 ;
19716 int ecode2 = 0 ;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 char * kwnames[] = {
19720 (char *) "self",(char *) "orient", NULL
19721 };
19722
19723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19725 if (!SWIG_IsOK(res1)) {
19726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19727 }
19728 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19729 ecode2 = SWIG_AsVal_int(obj1, &val2);
19730 if (!SWIG_IsOK(ecode2)) {
19731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19732 }
19733 arg2 = static_cast< int >(val2);
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 (arg1)->SetOrientation(arg2);
19737 wxPyEndAllowThreads(__tstate);
19738 if (PyErr_Occurred()) SWIG_fail;
19739 }
19740 resultobj = SWIG_Py_Void();
19741 return resultobj;
19742 fail:
19743 return NULL;
19744 }
19745
19746
19747 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19748 PyObject *resultobj = 0;
19749 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19750 int arg2 ;
19751 void *argp1 = 0 ;
19752 int res1 = 0 ;
19753 int val2 ;
19754 int ecode2 = 0 ;
19755 PyObject * obj0 = 0 ;
19756 PyObject * obj1 = 0 ;
19757 char * kwnames[] = {
19758 (char *) "self",(char *) "pos", NULL
19759 };
19760
19761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19763 if (!SWIG_IsOK(res1)) {
19764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19765 }
19766 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19767 ecode2 = SWIG_AsVal_int(obj1, &val2);
19768 if (!SWIG_IsOK(ecode2)) {
19769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19770 }
19771 arg2 = static_cast< int >(val2);
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 (arg1)->SetPosition(arg2);
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 resultobj = SWIG_Py_Void();
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19786 PyObject *obj;
19787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19788 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19789 return SWIG_Py_Void();
19790 }
19791
19792 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19793 return SWIG_Python_InitShadowInstance(args);
19794 }
19795
19796 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj = 0;
19798 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19799 int arg2 = (int) 0 ;
19800 int arg3 = (int) 0 ;
19801 wxScrollWinEvent *result = 0 ;
19802 int val1 ;
19803 int ecode1 = 0 ;
19804 int val2 ;
19805 int ecode2 = 0 ;
19806 int val3 ;
19807 int ecode3 = 0 ;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 PyObject * obj2 = 0 ;
19811 char * kwnames[] = {
19812 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19813 };
19814
19815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19816 if (obj0) {
19817 ecode1 = SWIG_AsVal_int(obj0, &val1);
19818 if (!SWIG_IsOK(ecode1)) {
19819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19820 }
19821 arg1 = static_cast< wxEventType >(val1);
19822 }
19823 if (obj1) {
19824 ecode2 = SWIG_AsVal_int(obj1, &val2);
19825 if (!SWIG_IsOK(ecode2)) {
19826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19827 }
19828 arg2 = static_cast< int >(val2);
19829 }
19830 if (obj2) {
19831 ecode3 = SWIG_AsVal_int(obj2, &val3);
19832 if (!SWIG_IsOK(ecode3)) {
19833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19834 }
19835 arg3 = static_cast< int >(val3);
19836 }
19837 {
19838 PyThreadState* __tstate = wxPyBeginAllowThreads();
19839 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19840 wxPyEndAllowThreads(__tstate);
19841 if (PyErr_Occurred()) SWIG_fail;
19842 }
19843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19844 return resultobj;
19845 fail:
19846 return NULL;
19847 }
19848
19849
19850 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19851 PyObject *resultobj = 0;
19852 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19853 int result;
19854 void *argp1 = 0 ;
19855 int res1 = 0 ;
19856 PyObject *swig_obj[1] ;
19857
19858 if (!args) SWIG_fail;
19859 swig_obj[0] = args;
19860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19861 if (!SWIG_IsOK(res1)) {
19862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19863 }
19864 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19868 wxPyEndAllowThreads(__tstate);
19869 if (PyErr_Occurred()) SWIG_fail;
19870 }
19871 resultobj = SWIG_From_int(static_cast< int >(result));
19872 return resultobj;
19873 fail:
19874 return NULL;
19875 }
19876
19877
19878 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19879 PyObject *resultobj = 0;
19880 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19881 int result;
19882 void *argp1 = 0 ;
19883 int res1 = 0 ;
19884 PyObject *swig_obj[1] ;
19885
19886 if (!args) SWIG_fail;
19887 swig_obj[0] = args;
19888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19889 if (!SWIG_IsOK(res1)) {
19890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19891 }
19892 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19893 {
19894 PyThreadState* __tstate = wxPyBeginAllowThreads();
19895 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19896 wxPyEndAllowThreads(__tstate);
19897 if (PyErr_Occurred()) SWIG_fail;
19898 }
19899 resultobj = SWIG_From_int(static_cast< int >(result));
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19907 PyObject *resultobj = 0;
19908 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19909 int arg2 ;
19910 void *argp1 = 0 ;
19911 int res1 = 0 ;
19912 int val2 ;
19913 int ecode2 = 0 ;
19914 PyObject * obj0 = 0 ;
19915 PyObject * obj1 = 0 ;
19916 char * kwnames[] = {
19917 (char *) "self",(char *) "orient", NULL
19918 };
19919
19920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19922 if (!SWIG_IsOK(res1)) {
19923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19924 }
19925 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19926 ecode2 = SWIG_AsVal_int(obj1, &val2);
19927 if (!SWIG_IsOK(ecode2)) {
19928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19929 }
19930 arg2 = static_cast< int >(val2);
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 (arg1)->SetOrientation(arg2);
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 resultobj = SWIG_Py_Void();
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19945 PyObject *resultobj = 0;
19946 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19947 int arg2 ;
19948 void *argp1 = 0 ;
19949 int res1 = 0 ;
19950 int val2 ;
19951 int ecode2 = 0 ;
19952 PyObject * obj0 = 0 ;
19953 PyObject * obj1 = 0 ;
19954 char * kwnames[] = {
19955 (char *) "self",(char *) "pos", NULL
19956 };
19957
19958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19960 if (!SWIG_IsOK(res1)) {
19961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19962 }
19963 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19964 ecode2 = SWIG_AsVal_int(obj1, &val2);
19965 if (!SWIG_IsOK(ecode2)) {
19966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19967 }
19968 arg2 = static_cast< int >(val2);
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 (arg1)->SetPosition(arg2);
19972 wxPyEndAllowThreads(__tstate);
19973 if (PyErr_Occurred()) SWIG_fail;
19974 }
19975 resultobj = SWIG_Py_Void();
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19983 PyObject *obj;
19984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19985 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19986 return SWIG_Py_Void();
19987 }
19988
19989 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19990 return SWIG_Python_InitShadowInstance(args);
19991 }
19992
19993 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19994 PyObject *resultobj = 0;
19995 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19996 wxMouseEvent *result = 0 ;
19997 int val1 ;
19998 int ecode1 = 0 ;
19999 PyObject * obj0 = 0 ;
20000 char * kwnames[] = {
20001 (char *) "mouseType", NULL
20002 };
20003
20004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20005 if (obj0) {
20006 ecode1 = SWIG_AsVal_int(obj0, &val1);
20007 if (!SWIG_IsOK(ecode1)) {
20008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20009 }
20010 arg1 = static_cast< wxEventType >(val1);
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 {
20019 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20020 }
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20028 PyObject *resultobj = 0;
20029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20030 bool result;
20031 void *argp1 = 0 ;
20032 int res1 = 0 ;
20033 PyObject *swig_obj[1] ;
20034
20035 if (!args) SWIG_fail;
20036 swig_obj[0] = args;
20037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
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_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj = 0;
20059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20060 int arg2 = (int) wxMOUSE_BTN_ANY ;
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 *)"O|O:MouseEvent_ButtonDown",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_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20076 }
20077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20078 if (obj1) {
20079 ecode2 = SWIG_AsVal_int(obj1, &val2);
20080 if (!SWIG_IsOK(ecode2)) {
20081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20082 }
20083 arg2 = static_cast< int >(val2);
20084 }
20085 {
20086 PyThreadState* __tstate = wxPyBeginAllowThreads();
20087 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20088 wxPyEndAllowThreads(__tstate);
20089 if (PyErr_Occurred()) SWIG_fail;
20090 }
20091 {
20092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20093 }
20094 return resultobj;
20095 fail:
20096 return NULL;
20097 }
20098
20099
20100 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj = 0;
20102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20103 int arg2 = (int) wxMOUSE_BTN_ANY ;
20104 bool result;
20105 void *argp1 = 0 ;
20106 int res1 = 0 ;
20107 int val2 ;
20108 int ecode2 = 0 ;
20109 PyObject * obj0 = 0 ;
20110 PyObject * obj1 = 0 ;
20111 char * kwnames[] = {
20112 (char *) "self",(char *) "but", NULL
20113 };
20114
20115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20117 if (!SWIG_IsOK(res1)) {
20118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20119 }
20120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20121 if (obj1) {
20122 ecode2 = SWIG_AsVal_int(obj1, &val2);
20123 if (!SWIG_IsOK(ecode2)) {
20124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20125 }
20126 arg2 = static_cast< int >(val2);
20127 }
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 {
20135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20136 }
20137 return resultobj;
20138 fail:
20139 return NULL;
20140 }
20141
20142
20143 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20144 PyObject *resultobj = 0;
20145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20146 int arg2 = (int) wxMOUSE_BTN_ANY ;
20147 bool result;
20148 void *argp1 = 0 ;
20149 int res1 = 0 ;
20150 int val2 ;
20151 int ecode2 = 0 ;
20152 PyObject * obj0 = 0 ;
20153 PyObject * obj1 = 0 ;
20154 char * kwnames[] = {
20155 (char *) "self",(char *) "but", NULL
20156 };
20157
20158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20160 if (!SWIG_IsOK(res1)) {
20161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20162 }
20163 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20164 if (obj1) {
20165 ecode2 = SWIG_AsVal_int(obj1, &val2);
20166 if (!SWIG_IsOK(ecode2)) {
20167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20168 }
20169 arg2 = static_cast< int >(val2);
20170 }
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
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_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20187 PyObject *resultobj = 0;
20188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20189 int arg2 ;
20190 bool result;
20191 void *argp1 = 0 ;
20192 int res1 = 0 ;
20193 int val2 ;
20194 int ecode2 = 0 ;
20195 PyObject * obj0 = 0 ;
20196 PyObject * obj1 = 0 ;
20197 char * kwnames[] = {
20198 (char *) "self",(char *) "button", NULL
20199 };
20200
20201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20203 if (!SWIG_IsOK(res1)) {
20204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20205 }
20206 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20207 ecode2 = SWIG_AsVal_int(obj1, &val2);
20208 if (!SWIG_IsOK(ecode2)) {
20209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20210 }
20211 arg2 = static_cast< int >(val2);
20212 {
20213 PyThreadState* __tstate = wxPyBeginAllowThreads();
20214 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20215 wxPyEndAllowThreads(__tstate);
20216 if (PyErr_Occurred()) SWIG_fail;
20217 }
20218 {
20219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20220 }
20221 return resultobj;
20222 fail:
20223 return NULL;
20224 }
20225
20226
20227 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20228 PyObject *resultobj = 0;
20229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20230 int arg2 ;
20231 bool result;
20232 void *argp1 = 0 ;
20233 int res1 = 0 ;
20234 int val2 ;
20235 int ecode2 = 0 ;
20236 PyObject * obj0 = 0 ;
20237 PyObject * obj1 = 0 ;
20238 char * kwnames[] = {
20239 (char *) "self",(char *) "but", NULL
20240 };
20241
20242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20244 if (!SWIG_IsOK(res1)) {
20245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20246 }
20247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20248 ecode2 = SWIG_AsVal_int(obj1, &val2);
20249 if (!SWIG_IsOK(ecode2)) {
20250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20251 }
20252 arg2 = static_cast< int >(val2);
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20256 wxPyEndAllowThreads(__tstate);
20257 if (PyErr_Occurred()) SWIG_fail;
20258 }
20259 {
20260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20261 }
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20269 PyObject *resultobj = 0;
20270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20271 int result;
20272 void *argp1 = 0 ;
20273 int res1 = 0 ;
20274 PyObject *swig_obj[1] ;
20275
20276 if (!args) SWIG_fail;
20277 swig_obj[0] = args;
20278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20279 if (!SWIG_IsOK(res1)) {
20280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20281 }
20282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20283 {
20284 PyThreadState* __tstate = wxPyBeginAllowThreads();
20285 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 resultobj = SWIG_From_int(static_cast< int >(result));
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20297 PyObject *resultobj = 0;
20298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20299 bool result;
20300 void *argp1 = 0 ;
20301 int res1 = 0 ;
20302 PyObject *swig_obj[1] ;
20303
20304 if (!args) SWIG_fail;
20305 swig_obj[0] = args;
20306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20307 if (!SWIG_IsOK(res1)) {
20308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20309 }
20310 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20311 {
20312 PyThreadState* __tstate = wxPyBeginAllowThreads();
20313 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 {
20318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20319 }
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20327 PyObject *resultobj = 0;
20328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20329 bool result;
20330 void *argp1 = 0 ;
20331 int res1 = 0 ;
20332 PyObject *swig_obj[1] ;
20333
20334 if (!args) SWIG_fail;
20335 swig_obj[0] = args;
20336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20337 if (!SWIG_IsOK(res1)) {
20338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20339 }
20340 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20344 wxPyEndAllowThreads(__tstate);
20345 if (PyErr_Occurred()) SWIG_fail;
20346 }
20347 {
20348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20349 }
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 PyObject *resultobj = 0;
20358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20359 bool result;
20360 void *argp1 = 0 ;
20361 int res1 = 0 ;
20362 PyObject *swig_obj[1] ;
20363
20364 if (!args) SWIG_fail;
20365 swig_obj[0] = args;
20366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20367 if (!SWIG_IsOK(res1)) {
20368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20369 }
20370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 {
20378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20379 }
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 PyObject *resultobj = 0;
20388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20389 bool result;
20390 void *argp1 = 0 ;
20391 int res1 = 0 ;
20392 PyObject *swig_obj[1] ;
20393
20394 if (!args) SWIG_fail;
20395 swig_obj[0] = args;
20396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20397 if (!SWIG_IsOK(res1)) {
20398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20399 }
20400 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 {
20408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20409 }
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20419 bool result;
20420 void *argp1 = 0 ;
20421 int res1 = 0 ;
20422 PyObject *swig_obj[1] ;
20423
20424 if (!args) SWIG_fail;
20425 swig_obj[0] = args;
20426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20427 if (!SWIG_IsOK(res1)) {
20428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20429 }
20430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20431 {
20432 PyThreadState* __tstate = wxPyBeginAllowThreads();
20433 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20439 }
20440 return resultobj;
20441 fail:
20442 return NULL;
20443 }
20444
20445
20446 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20447 PyObject *resultobj = 0;
20448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20449 bool result;
20450 void *argp1 = 0 ;
20451 int res1 = 0 ;
20452 PyObject *swig_obj[1] ;
20453
20454 if (!args) SWIG_fail;
20455 swig_obj[0] = args;
20456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20457 if (!SWIG_IsOK(res1)) {
20458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20459 }
20460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20461 {
20462 PyThreadState* __tstate = wxPyBeginAllowThreads();
20463 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20464 wxPyEndAllowThreads(__tstate);
20465 if (PyErr_Occurred()) SWIG_fail;
20466 }
20467 {
20468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20469 }
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20477 PyObject *resultobj = 0;
20478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20479 bool result;
20480 void *argp1 = 0 ;
20481 int res1 = 0 ;
20482 PyObject *swig_obj[1] ;
20483
20484 if (!args) SWIG_fail;
20485 swig_obj[0] = args;
20486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20487 if (!SWIG_IsOK(res1)) {
20488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20489 }
20490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20491 {
20492 PyThreadState* __tstate = wxPyBeginAllowThreads();
20493 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20494 wxPyEndAllowThreads(__tstate);
20495 if (PyErr_Occurred()) SWIG_fail;
20496 }
20497 {
20498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20499 }
20500 return resultobj;
20501 fail:
20502 return NULL;
20503 }
20504
20505
20506 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20507 PyObject *resultobj = 0;
20508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20509 bool result;
20510 void *argp1 = 0 ;
20511 int res1 = 0 ;
20512 PyObject *swig_obj[1] ;
20513
20514 if (!args) SWIG_fail;
20515 swig_obj[0] = args;
20516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20517 if (!SWIG_IsOK(res1)) {
20518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20519 }
20520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20521 {
20522 PyThreadState* __tstate = wxPyBeginAllowThreads();
20523 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20524 wxPyEndAllowThreads(__tstate);
20525 if (PyErr_Occurred()) SWIG_fail;
20526 }
20527 {
20528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20529 }
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20537 PyObject *resultobj = 0;
20538 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20539 bool result;
20540 void *argp1 = 0 ;
20541 int res1 = 0 ;
20542 PyObject *swig_obj[1] ;
20543
20544 if (!args) SWIG_fail;
20545 swig_obj[0] = args;
20546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20547 if (!SWIG_IsOK(res1)) {
20548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20549 }
20550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20554 wxPyEndAllowThreads(__tstate);
20555 if (PyErr_Occurred()) SWIG_fail;
20556 }
20557 {
20558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20559 }
20560 return resultobj;
20561 fail:
20562 return NULL;
20563 }
20564
20565
20566 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20567 PyObject *resultobj = 0;
20568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20569 bool result;
20570 void *argp1 = 0 ;
20571 int res1 = 0 ;
20572 PyObject *swig_obj[1] ;
20573
20574 if (!args) SWIG_fail;
20575 swig_obj[0] = args;
20576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20577 if (!SWIG_IsOK(res1)) {
20578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20579 }
20580 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20584 wxPyEndAllowThreads(__tstate);
20585 if (PyErr_Occurred()) SWIG_fail;
20586 }
20587 {
20588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20589 }
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20597 PyObject *resultobj = 0;
20598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20599 bool result;
20600 void *argp1 = 0 ;
20601 int res1 = 0 ;
20602 PyObject *swig_obj[1] ;
20603
20604 if (!args) SWIG_fail;
20605 swig_obj[0] = args;
20606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20607 if (!SWIG_IsOK(res1)) {
20608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20609 }
20610 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20619 }
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 PyObject *resultobj = 0;
20628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20629 bool result;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 PyObject *swig_obj[1] ;
20633
20634 if (!args) SWIG_fail;
20635 swig_obj[0] = args;
20636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20639 }
20640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 {
20648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20657 PyObject *resultobj = 0;
20658 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20659 bool result;
20660 void *argp1 = 0 ;
20661 int res1 = 0 ;
20662 PyObject *swig_obj[1] ;
20663
20664 if (!args) SWIG_fail;
20665 swig_obj[0] = args;
20666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20669 }
20670 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 {
20678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20679 }
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20687 PyObject *resultobj = 0;
20688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20689 bool result;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 PyObject *swig_obj[1] ;
20693
20694 if (!args) SWIG_fail;
20695 swig_obj[0] = args;
20696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20697 if (!SWIG_IsOK(res1)) {
20698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20699 }
20700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20709 }
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20717 PyObject *resultobj = 0;
20718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20719 bool result;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 PyObject *swig_obj[1] ;
20723
20724 if (!args) SWIG_fail;
20725 swig_obj[0] = args;
20726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20727 if (!SWIG_IsOK(res1)) {
20728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20729 }
20730 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (bool)(arg1)->LeftIsDown();
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20747 PyObject *resultobj = 0;
20748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20749 bool result;
20750 void *argp1 = 0 ;
20751 int res1 = 0 ;
20752 PyObject *swig_obj[1] ;
20753
20754 if (!args) SWIG_fail;
20755 swig_obj[0] = args;
20756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20757 if (!SWIG_IsOK(res1)) {
20758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20759 }
20760 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 result = (bool)(arg1)->MiddleIsDown();
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 {
20768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20769 }
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20777 PyObject *resultobj = 0;
20778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 PyObject *swig_obj[1] ;
20783
20784 if (!args) SWIG_fail;
20785 swig_obj[0] = args;
20786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20787 if (!SWIG_IsOK(res1)) {
20788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20789 }
20790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20791 {
20792 PyThreadState* __tstate = wxPyBeginAllowThreads();
20793 result = (bool)(arg1)->RightIsDown();
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 {
20798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20799 }
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20807 PyObject *resultobj = 0;
20808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20809 bool result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20819 }
20820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 PyObject *resultobj = 0;
20838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20839 bool result;
20840 void *argp1 = 0 ;
20841 int res1 = 0 ;
20842 PyObject *swig_obj[1] ;
20843
20844 if (!args) SWIG_fail;
20845 swig_obj[0] = args;
20846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20849 }
20850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20859 }
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20869 bool result;
20870 void *argp1 = 0 ;
20871 int res1 = 0 ;
20872 PyObject *swig_obj[1] ;
20873
20874 if (!args) SWIG_fail;
20875 swig_obj[0] = args;
20876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20877 if (!SWIG_IsOK(res1)) {
20878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20879 }
20880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 {
20888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20897 PyObject *resultobj = 0;
20898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20899 bool result;
20900 void *argp1 = 0 ;
20901 int res1 = 0 ;
20902 PyObject *swig_obj[1] ;
20903
20904 if (!args) SWIG_fail;
20905 swig_obj[0] = args;
20906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20909 }
20910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20914 wxPyEndAllowThreads(__tstate);
20915 if (PyErr_Occurred()) SWIG_fail;
20916 }
20917 {
20918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20919 }
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20929 wxPoint result;
20930 void *argp1 = 0 ;
20931 int res1 = 0 ;
20932 PyObject *swig_obj[1] ;
20933
20934 if (!args) SWIG_fail;
20935 swig_obj[0] = args;
20936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20939 }
20940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (arg1)->GetPosition();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20955 PyObject *resultobj = 0;
20956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20957 long *arg2 = (long *) 0 ;
20958 long *arg3 = (long *) 0 ;
20959 void *argp1 = 0 ;
20960 int res1 = 0 ;
20961 long temp2 ;
20962 int res2 = SWIG_TMPOBJ ;
20963 long temp3 ;
20964 int res3 = SWIG_TMPOBJ ;
20965 PyObject *swig_obj[1] ;
20966
20967 arg2 = &temp2;
20968 arg3 = &temp3;
20969 if (!args) SWIG_fail;
20970 swig_obj[0] = args;
20971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20972 if (!SWIG_IsOK(res1)) {
20973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20974 }
20975 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20976 {
20977 PyThreadState* __tstate = wxPyBeginAllowThreads();
20978 (arg1)->GetPosition(arg2,arg3);
20979 wxPyEndAllowThreads(__tstate);
20980 if (PyErr_Occurred()) SWIG_fail;
20981 }
20982 resultobj = SWIG_Py_Void();
20983 if (SWIG_IsTmpObj(res2)) {
20984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20985 } else {
20986 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20988 }
20989 if (SWIG_IsTmpObj(res3)) {
20990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20991 } else {
20992 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20994 }
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj = 0;
21003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21004 wxDC *arg2 = 0 ;
21005 wxPoint result;
21006 void *argp1 = 0 ;
21007 int res1 = 0 ;
21008 void *argp2 = 0 ;
21009 int res2 = 0 ;
21010 PyObject * obj0 = 0 ;
21011 PyObject * obj1 = 0 ;
21012 char * kwnames[] = {
21013 (char *) "self",(char *) "dc", NULL
21014 };
21015
21016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21018 if (!SWIG_IsOK(res1)) {
21019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21020 }
21021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21022 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21023 if (!SWIG_IsOK(res2)) {
21024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21025 }
21026 if (!argp2) {
21027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21028 }
21029 arg2 = reinterpret_cast< wxDC * >(argp2);
21030 {
21031 PyThreadState* __tstate = wxPyBeginAllowThreads();
21032 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 PyObject *resultobj = 0;
21045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21046 int result;
21047 void *argp1 = 0 ;
21048 int res1 = 0 ;
21049 PyObject *swig_obj[1] ;
21050
21051 if (!args) SWIG_fail;
21052 swig_obj[0] = args;
21053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21054 if (!SWIG_IsOK(res1)) {
21055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21056 }
21057 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 result = (int)((wxMouseEvent const *)arg1)->GetX();
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 resultobj = SWIG_From_int(static_cast< int >(result));
21065 return resultobj;
21066 fail:
21067 return NULL;
21068 }
21069
21070
21071 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21072 PyObject *resultobj = 0;
21073 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21074 int result;
21075 void *argp1 = 0 ;
21076 int res1 = 0 ;
21077 PyObject *swig_obj[1] ;
21078
21079 if (!args) SWIG_fail;
21080 swig_obj[0] = args;
21081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21082 if (!SWIG_IsOK(res1)) {
21083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21084 }
21085 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21086 {
21087 PyThreadState* __tstate = wxPyBeginAllowThreads();
21088 result = (int)((wxMouseEvent const *)arg1)->GetY();
21089 wxPyEndAllowThreads(__tstate);
21090 if (PyErr_Occurred()) SWIG_fail;
21091 }
21092 resultobj = SWIG_From_int(static_cast< int >(result));
21093 return resultobj;
21094 fail:
21095 return NULL;
21096 }
21097
21098
21099 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21100 PyObject *resultobj = 0;
21101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21102 int result;
21103 void *argp1 = 0 ;
21104 int res1 = 0 ;
21105 PyObject *swig_obj[1] ;
21106
21107 if (!args) SWIG_fail;
21108 swig_obj[0] = args;
21109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21110 if (!SWIG_IsOK(res1)) {
21111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21112 }
21113 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 resultobj = SWIG_From_int(static_cast< int >(result));
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21128 PyObject *resultobj = 0;
21129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21130 int result;
21131 void *argp1 = 0 ;
21132 int res1 = 0 ;
21133 PyObject *swig_obj[1] ;
21134
21135 if (!args) SWIG_fail;
21136 swig_obj[0] = args;
21137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21138 if (!SWIG_IsOK(res1)) {
21139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21140 }
21141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21142 {
21143 PyThreadState* __tstate = wxPyBeginAllowThreads();
21144 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 resultobj = SWIG_From_int(static_cast< int >(result));
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21156 PyObject *resultobj = 0;
21157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21158 int result;
21159 void *argp1 = 0 ;
21160 int res1 = 0 ;
21161 PyObject *swig_obj[1] ;
21162
21163 if (!args) SWIG_fail;
21164 swig_obj[0] = args;
21165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21166 if (!SWIG_IsOK(res1)) {
21167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21168 }
21169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21173 wxPyEndAllowThreads(__tstate);
21174 if (PyErr_Occurred()) SWIG_fail;
21175 }
21176 resultobj = SWIG_From_int(static_cast< int >(result));
21177 return resultobj;
21178 fail:
21179 return NULL;
21180 }
21181
21182
21183 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21184 PyObject *resultobj = 0;
21185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21186 bool result;
21187 void *argp1 = 0 ;
21188 int res1 = 0 ;
21189 PyObject *swig_obj[1] ;
21190
21191 if (!args) SWIG_fail;
21192 swig_obj[0] = args;
21193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21194 if (!SWIG_IsOK(res1)) {
21195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21196 }
21197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21201 wxPyEndAllowThreads(__tstate);
21202 if (PyErr_Occurred()) SWIG_fail;
21203 }
21204 {
21205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21206 }
21207 return resultobj;
21208 fail:
21209 return NULL;
21210 }
21211
21212
21213 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21214 PyObject *resultobj = 0;
21215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21216 int arg2 ;
21217 void *argp1 = 0 ;
21218 int res1 = 0 ;
21219 int val2 ;
21220 int ecode2 = 0 ;
21221 PyObject *swig_obj[2] ;
21222
21223 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21225 if (!SWIG_IsOK(res1)) {
21226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21227 }
21228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21229 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21230 if (!SWIG_IsOK(ecode2)) {
21231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21232 }
21233 arg2 = static_cast< int >(val2);
21234 if (arg1) (arg1)->m_x = arg2;
21235
21236 resultobj = SWIG_Py_Void();
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21244 PyObject *resultobj = 0;
21245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21246 int result;
21247 void *argp1 = 0 ;
21248 int res1 = 0 ;
21249 PyObject *swig_obj[1] ;
21250
21251 if (!args) SWIG_fail;
21252 swig_obj[0] = args;
21253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21256 }
21257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21258 result = (int) ((arg1)->m_x);
21259 resultobj = SWIG_From_int(static_cast< int >(result));
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267 PyObject *resultobj = 0;
21268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21269 int arg2 ;
21270 void *argp1 = 0 ;
21271 int res1 = 0 ;
21272 int val2 ;
21273 int ecode2 = 0 ;
21274 PyObject *swig_obj[2] ;
21275
21276 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21278 if (!SWIG_IsOK(res1)) {
21279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21280 }
21281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21282 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21283 if (!SWIG_IsOK(ecode2)) {
21284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21285 }
21286 arg2 = static_cast< int >(val2);
21287 if (arg1) (arg1)->m_y = arg2;
21288
21289 resultobj = SWIG_Py_Void();
21290 return resultobj;
21291 fail:
21292 return NULL;
21293 }
21294
21295
21296 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21297 PyObject *resultobj = 0;
21298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21299 int result;
21300 void *argp1 = 0 ;
21301 int res1 = 0 ;
21302 PyObject *swig_obj[1] ;
21303
21304 if (!args) SWIG_fail;
21305 swig_obj[0] = args;
21306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21307 if (!SWIG_IsOK(res1)) {
21308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21309 }
21310 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21311 result = (int) ((arg1)->m_y);
21312 resultobj = SWIG_From_int(static_cast< int >(result));
21313 return resultobj;
21314 fail:
21315 return NULL;
21316 }
21317
21318
21319 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21320 PyObject *resultobj = 0;
21321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21322 bool arg2 ;
21323 void *argp1 = 0 ;
21324 int res1 = 0 ;
21325 bool val2 ;
21326 int ecode2 = 0 ;
21327 PyObject *swig_obj[2] ;
21328
21329 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21331 if (!SWIG_IsOK(res1)) {
21332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21333 }
21334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21335 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21336 if (!SWIG_IsOK(ecode2)) {
21337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21338 }
21339 arg2 = static_cast< bool >(val2);
21340 if (arg1) (arg1)->m_leftDown = arg2;
21341
21342 resultobj = SWIG_Py_Void();
21343 return resultobj;
21344 fail:
21345 return NULL;
21346 }
21347
21348
21349 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21350 PyObject *resultobj = 0;
21351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21352 bool result;
21353 void *argp1 = 0 ;
21354 int res1 = 0 ;
21355 PyObject *swig_obj[1] ;
21356
21357 if (!args) SWIG_fail;
21358 swig_obj[0] = args;
21359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21360 if (!SWIG_IsOK(res1)) {
21361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21362 }
21363 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21364 result = (bool) ((arg1)->m_leftDown);
21365 {
21366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21367 }
21368 return resultobj;
21369 fail:
21370 return NULL;
21371 }
21372
21373
21374 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21375 PyObject *resultobj = 0;
21376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21377 bool arg2 ;
21378 void *argp1 = 0 ;
21379 int res1 = 0 ;
21380 bool val2 ;
21381 int ecode2 = 0 ;
21382 PyObject *swig_obj[2] ;
21383
21384 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21386 if (!SWIG_IsOK(res1)) {
21387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21388 }
21389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21390 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21391 if (!SWIG_IsOK(ecode2)) {
21392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21393 }
21394 arg2 = static_cast< bool >(val2);
21395 if (arg1) (arg1)->m_middleDown = arg2;
21396
21397 resultobj = SWIG_Py_Void();
21398 return resultobj;
21399 fail:
21400 return NULL;
21401 }
21402
21403
21404 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21405 PyObject *resultobj = 0;
21406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21407 bool result;
21408 void *argp1 = 0 ;
21409 int res1 = 0 ;
21410 PyObject *swig_obj[1] ;
21411
21412 if (!args) SWIG_fail;
21413 swig_obj[0] = args;
21414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21415 if (!SWIG_IsOK(res1)) {
21416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21417 }
21418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21419 result = (bool) ((arg1)->m_middleDown);
21420 {
21421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21422 }
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21430 PyObject *resultobj = 0;
21431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21432 bool arg2 ;
21433 void *argp1 = 0 ;
21434 int res1 = 0 ;
21435 bool val2 ;
21436 int ecode2 = 0 ;
21437 PyObject *swig_obj[2] ;
21438
21439 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21441 if (!SWIG_IsOK(res1)) {
21442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21443 }
21444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21445 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21446 if (!SWIG_IsOK(ecode2)) {
21447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21448 }
21449 arg2 = static_cast< bool >(val2);
21450 if (arg1) (arg1)->m_rightDown = arg2;
21451
21452 resultobj = SWIG_Py_Void();
21453 return resultobj;
21454 fail:
21455 return NULL;
21456 }
21457
21458
21459 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21460 PyObject *resultobj = 0;
21461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21462 bool result;
21463 void *argp1 = 0 ;
21464 int res1 = 0 ;
21465 PyObject *swig_obj[1] ;
21466
21467 if (!args) SWIG_fail;
21468 swig_obj[0] = args;
21469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21470 if (!SWIG_IsOK(res1)) {
21471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21472 }
21473 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21474 result = (bool) ((arg1)->m_rightDown);
21475 {
21476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21477 }
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21485 PyObject *resultobj = 0;
21486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21487 bool arg2 ;
21488 void *argp1 = 0 ;
21489 int res1 = 0 ;
21490 bool val2 ;
21491 int ecode2 = 0 ;
21492 PyObject *swig_obj[2] ;
21493
21494 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21496 if (!SWIG_IsOK(res1)) {
21497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21498 }
21499 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21500 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21501 if (!SWIG_IsOK(ecode2)) {
21502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21503 }
21504 arg2 = static_cast< bool >(val2);
21505 if (arg1) (arg1)->m_controlDown = arg2;
21506
21507 resultobj = SWIG_Py_Void();
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21515 PyObject *resultobj = 0;
21516 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21517 bool result;
21518 void *argp1 = 0 ;
21519 int res1 = 0 ;
21520 PyObject *swig_obj[1] ;
21521
21522 if (!args) SWIG_fail;
21523 swig_obj[0] = args;
21524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21525 if (!SWIG_IsOK(res1)) {
21526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21527 }
21528 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21529 result = (bool) ((arg1)->m_controlDown);
21530 {
21531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21532 }
21533 return resultobj;
21534 fail:
21535 return NULL;
21536 }
21537
21538
21539 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21540 PyObject *resultobj = 0;
21541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21542 bool arg2 ;
21543 void *argp1 = 0 ;
21544 int res1 = 0 ;
21545 bool val2 ;
21546 int ecode2 = 0 ;
21547 PyObject *swig_obj[2] ;
21548
21549 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21551 if (!SWIG_IsOK(res1)) {
21552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21553 }
21554 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21555 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21556 if (!SWIG_IsOK(ecode2)) {
21557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21558 }
21559 arg2 = static_cast< bool >(val2);
21560 if (arg1) (arg1)->m_shiftDown = arg2;
21561
21562 resultobj = SWIG_Py_Void();
21563 return resultobj;
21564 fail:
21565 return NULL;
21566 }
21567
21568
21569 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21570 PyObject *resultobj = 0;
21571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21572 bool result;
21573 void *argp1 = 0 ;
21574 int res1 = 0 ;
21575 PyObject *swig_obj[1] ;
21576
21577 if (!args) SWIG_fail;
21578 swig_obj[0] = args;
21579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21580 if (!SWIG_IsOK(res1)) {
21581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21582 }
21583 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21584 result = (bool) ((arg1)->m_shiftDown);
21585 {
21586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21587 }
21588 return resultobj;
21589 fail:
21590 return NULL;
21591 }
21592
21593
21594 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21595 PyObject *resultobj = 0;
21596 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21597 bool arg2 ;
21598 void *argp1 = 0 ;
21599 int res1 = 0 ;
21600 bool val2 ;
21601 int ecode2 = 0 ;
21602 PyObject *swig_obj[2] ;
21603
21604 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21606 if (!SWIG_IsOK(res1)) {
21607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21608 }
21609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21610 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21611 if (!SWIG_IsOK(ecode2)) {
21612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21613 }
21614 arg2 = static_cast< bool >(val2);
21615 if (arg1) (arg1)->m_altDown = arg2;
21616
21617 resultobj = SWIG_Py_Void();
21618 return resultobj;
21619 fail:
21620 return NULL;
21621 }
21622
21623
21624 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21625 PyObject *resultobj = 0;
21626 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21627 bool result;
21628 void *argp1 = 0 ;
21629 int res1 = 0 ;
21630 PyObject *swig_obj[1] ;
21631
21632 if (!args) SWIG_fail;
21633 swig_obj[0] = args;
21634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21637 }
21638 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21639 result = (bool) ((arg1)->m_altDown);
21640 {
21641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21642 }
21643 return resultobj;
21644 fail:
21645 return NULL;
21646 }
21647
21648
21649 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21650 PyObject *resultobj = 0;
21651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21652 bool arg2 ;
21653 void *argp1 = 0 ;
21654 int res1 = 0 ;
21655 bool val2 ;
21656 int ecode2 = 0 ;
21657 PyObject *swig_obj[2] ;
21658
21659 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21661 if (!SWIG_IsOK(res1)) {
21662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21663 }
21664 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21665 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21666 if (!SWIG_IsOK(ecode2)) {
21667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21668 }
21669 arg2 = static_cast< bool >(val2);
21670 if (arg1) (arg1)->m_metaDown = arg2;
21671
21672 resultobj = SWIG_Py_Void();
21673 return resultobj;
21674 fail:
21675 return NULL;
21676 }
21677
21678
21679 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21680 PyObject *resultobj = 0;
21681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21682 bool result;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 PyObject *swig_obj[1] ;
21686
21687 if (!args) SWIG_fail;
21688 swig_obj[0] = args;
21689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21690 if (!SWIG_IsOK(res1)) {
21691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21692 }
21693 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21694 result = (bool) ((arg1)->m_metaDown);
21695 {
21696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21697 }
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21705 PyObject *resultobj = 0;
21706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21707 int arg2 ;
21708 void *argp1 = 0 ;
21709 int res1 = 0 ;
21710 int val2 ;
21711 int ecode2 = 0 ;
21712 PyObject *swig_obj[2] ;
21713
21714 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21716 if (!SWIG_IsOK(res1)) {
21717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21718 }
21719 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21720 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21721 if (!SWIG_IsOK(ecode2)) {
21722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21723 }
21724 arg2 = static_cast< int >(val2);
21725 if (arg1) (arg1)->m_wheelRotation = arg2;
21726
21727 resultobj = SWIG_Py_Void();
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21735 PyObject *resultobj = 0;
21736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21737 int result;
21738 void *argp1 = 0 ;
21739 int res1 = 0 ;
21740 PyObject *swig_obj[1] ;
21741
21742 if (!args) SWIG_fail;
21743 swig_obj[0] = args;
21744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21745 if (!SWIG_IsOK(res1)) {
21746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21747 }
21748 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21749 result = (int) ((arg1)->m_wheelRotation);
21750 resultobj = SWIG_From_int(static_cast< int >(result));
21751 return resultobj;
21752 fail:
21753 return NULL;
21754 }
21755
21756
21757 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21758 PyObject *resultobj = 0;
21759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21760 int arg2 ;
21761 void *argp1 = 0 ;
21762 int res1 = 0 ;
21763 int val2 ;
21764 int ecode2 = 0 ;
21765 PyObject *swig_obj[2] ;
21766
21767 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21769 if (!SWIG_IsOK(res1)) {
21770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21771 }
21772 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21773 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21774 if (!SWIG_IsOK(ecode2)) {
21775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21776 }
21777 arg2 = static_cast< int >(val2);
21778 if (arg1) (arg1)->m_wheelDelta = arg2;
21779
21780 resultobj = SWIG_Py_Void();
21781 return resultobj;
21782 fail:
21783 return NULL;
21784 }
21785
21786
21787 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21788 PyObject *resultobj = 0;
21789 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21790 int result;
21791 void *argp1 = 0 ;
21792 int res1 = 0 ;
21793 PyObject *swig_obj[1] ;
21794
21795 if (!args) SWIG_fail;
21796 swig_obj[0] = args;
21797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21798 if (!SWIG_IsOK(res1)) {
21799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21800 }
21801 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21802 result = (int) ((arg1)->m_wheelDelta);
21803 resultobj = SWIG_From_int(static_cast< int >(result));
21804 return resultobj;
21805 fail:
21806 return NULL;
21807 }
21808
21809
21810 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21811 PyObject *resultobj = 0;
21812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21813 int arg2 ;
21814 void *argp1 = 0 ;
21815 int res1 = 0 ;
21816 int val2 ;
21817 int ecode2 = 0 ;
21818 PyObject *swig_obj[2] ;
21819
21820 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21824 }
21825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21826 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21827 if (!SWIG_IsOK(ecode2)) {
21828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21829 }
21830 arg2 = static_cast< int >(val2);
21831 if (arg1) (arg1)->m_linesPerAction = arg2;
21832
21833 resultobj = SWIG_Py_Void();
21834 return resultobj;
21835 fail:
21836 return NULL;
21837 }
21838
21839
21840 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21841 PyObject *resultobj = 0;
21842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21843 int result;
21844 void *argp1 = 0 ;
21845 int res1 = 0 ;
21846 PyObject *swig_obj[1] ;
21847
21848 if (!args) SWIG_fail;
21849 swig_obj[0] = args;
21850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21851 if (!SWIG_IsOK(res1)) {
21852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21853 }
21854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21855 result = (int) ((arg1)->m_linesPerAction);
21856 resultobj = SWIG_From_int(static_cast< int >(result));
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21864 PyObject *obj;
21865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21866 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21867 return SWIG_Py_Void();
21868 }
21869
21870 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 return SWIG_Python_InitShadowInstance(args);
21872 }
21873
21874 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21875 PyObject *resultobj = 0;
21876 int arg1 = (int) 0 ;
21877 int arg2 = (int) 0 ;
21878 wxSetCursorEvent *result = 0 ;
21879 int val1 ;
21880 int ecode1 = 0 ;
21881 int val2 ;
21882 int ecode2 = 0 ;
21883 PyObject * obj0 = 0 ;
21884 PyObject * obj1 = 0 ;
21885 char * kwnames[] = {
21886 (char *) "x",(char *) "y", NULL
21887 };
21888
21889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21890 if (obj0) {
21891 ecode1 = SWIG_AsVal_int(obj0, &val1);
21892 if (!SWIG_IsOK(ecode1)) {
21893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21894 }
21895 arg1 = static_cast< int >(val1);
21896 }
21897 if (obj1) {
21898 ecode2 = SWIG_AsVal_int(obj1, &val2);
21899 if (!SWIG_IsOK(ecode2)) {
21900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21901 }
21902 arg2 = static_cast< int >(val2);
21903 }
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21907 wxPyEndAllowThreads(__tstate);
21908 if (PyErr_Occurred()) SWIG_fail;
21909 }
21910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21911 return resultobj;
21912 fail:
21913 return NULL;
21914 }
21915
21916
21917 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21918 PyObject *resultobj = 0;
21919 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21920 int result;
21921 void *argp1 = 0 ;
21922 int res1 = 0 ;
21923 PyObject *swig_obj[1] ;
21924
21925 if (!args) SWIG_fail;
21926 swig_obj[0] = args;
21927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21928 if (!SWIG_IsOK(res1)) {
21929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21930 }
21931 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21932 {
21933 PyThreadState* __tstate = wxPyBeginAllowThreads();
21934 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21935 wxPyEndAllowThreads(__tstate);
21936 if (PyErr_Occurred()) SWIG_fail;
21937 }
21938 resultobj = SWIG_From_int(static_cast< int >(result));
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 PyObject *resultobj = 0;
21947 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21948 int result;
21949 void *argp1 = 0 ;
21950 int res1 = 0 ;
21951 PyObject *swig_obj[1] ;
21952
21953 if (!args) SWIG_fail;
21954 swig_obj[0] = args;
21955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21956 if (!SWIG_IsOK(res1)) {
21957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21958 }
21959 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 resultobj = SWIG_From_int(static_cast< int >(result));
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj = 0;
21975 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21976 wxCursor *arg2 = 0 ;
21977 void *argp1 = 0 ;
21978 int res1 = 0 ;
21979 void *argp2 = 0 ;
21980 int res2 = 0 ;
21981 PyObject * obj0 = 0 ;
21982 PyObject * obj1 = 0 ;
21983 char * kwnames[] = {
21984 (char *) "self",(char *) "cursor", NULL
21985 };
21986
21987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21989 if (!SWIG_IsOK(res1)) {
21990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21991 }
21992 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21994 if (!SWIG_IsOK(res2)) {
21995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21996 }
21997 if (!argp2) {
21998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21999 }
22000 arg2 = reinterpret_cast< wxCursor * >(argp2);
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 (arg1)->SetCursor((wxCursor const &)*arg2);
22004 wxPyEndAllowThreads(__tstate);
22005 if (PyErr_Occurred()) SWIG_fail;
22006 }
22007 resultobj = SWIG_Py_Void();
22008 return resultobj;
22009 fail:
22010 return NULL;
22011 }
22012
22013
22014 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22015 PyObject *resultobj = 0;
22016 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22017 wxCursor *result = 0 ;
22018 void *argp1 = 0 ;
22019 int res1 = 0 ;
22020 PyObject *swig_obj[1] ;
22021
22022 if (!args) SWIG_fail;
22023 swig_obj[0] = args;
22024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22025 if (!SWIG_IsOK(res1)) {
22026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22027 }
22028 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 {
22032 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22033 result = (wxCursor *) &_result_ref;
22034 }
22035 wxPyEndAllowThreads(__tstate);
22036 if (PyErr_Occurred()) SWIG_fail;
22037 }
22038 {
22039 wxCursor* resultptr = new wxCursor(*result);
22040 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22041 }
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22049 PyObject *resultobj = 0;
22050 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22051 bool result;
22052 void *argp1 = 0 ;
22053 int res1 = 0 ;
22054 PyObject *swig_obj[1] ;
22055
22056 if (!args) SWIG_fail;
22057 swig_obj[0] = args;
22058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22059 if (!SWIG_IsOK(res1)) {
22060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22061 }
22062 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 {
22070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22071 }
22072 return resultobj;
22073 fail:
22074 return NULL;
22075 }
22076
22077
22078 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22079 PyObject *obj;
22080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22081 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22082 return SWIG_Py_Void();
22083 }
22084
22085 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22086 return SWIG_Python_InitShadowInstance(args);
22087 }
22088
22089 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22090 PyObject *resultobj = 0;
22091 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22092 wxKeyEvent *result = 0 ;
22093 int val1 ;
22094 int ecode1 = 0 ;
22095 PyObject * obj0 = 0 ;
22096 char * kwnames[] = {
22097 (char *) "eventType", NULL
22098 };
22099
22100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22101 if (obj0) {
22102 ecode1 = SWIG_AsVal_int(obj0, &val1);
22103 if (!SWIG_IsOK(ecode1)) {
22104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22105 }
22106 arg1 = static_cast< wxEventType >(val1);
22107 }
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22122 PyObject *resultobj = 0;
22123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22124 int result;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject *swig_obj[1] ;
22128
22129 if (!args) SWIG_fail;
22130 swig_obj[0] = args;
22131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22132 if (!SWIG_IsOK(res1)) {
22133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22134 }
22135 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 resultobj = SWIG_From_int(static_cast< int >(result));
22143 return resultobj;
22144 fail:
22145 return NULL;
22146 }
22147
22148
22149 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22150 PyObject *resultobj = 0;
22151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22152 bool result;
22153 void *argp1 = 0 ;
22154 int res1 = 0 ;
22155 PyObject *swig_obj[1] ;
22156
22157 if (!args) SWIG_fail;
22158 swig_obj[0] = args;
22159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22160 if (!SWIG_IsOK(res1)) {
22161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22162 }
22163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 {
22171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22172 }
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22180 PyObject *resultobj = 0;
22181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22182 bool result;
22183 void *argp1 = 0 ;
22184 int res1 = 0 ;
22185 PyObject *swig_obj[1] ;
22186
22187 if (!args) SWIG_fail;
22188 swig_obj[0] = args;
22189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22190 if (!SWIG_IsOK(res1)) {
22191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22192 }
22193 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22194 {
22195 PyThreadState* __tstate = wxPyBeginAllowThreads();
22196 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 {
22201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22202 }
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *resultobj = 0;
22211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22212 bool result;
22213 void *argp1 = 0 ;
22214 int res1 = 0 ;
22215 PyObject *swig_obj[1] ;
22216
22217 if (!args) SWIG_fail;
22218 swig_obj[0] = args;
22219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22220 if (!SWIG_IsOK(res1)) {
22221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22222 }
22223 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22227 wxPyEndAllowThreads(__tstate);
22228 if (PyErr_Occurred()) SWIG_fail;
22229 }
22230 {
22231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22232 }
22233 return resultobj;
22234 fail:
22235 return NULL;
22236 }
22237
22238
22239 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22240 PyObject *resultobj = 0;
22241 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22242 bool result;
22243 void *argp1 = 0 ;
22244 int res1 = 0 ;
22245 PyObject *swig_obj[1] ;
22246
22247 if (!args) SWIG_fail;
22248 swig_obj[0] = args;
22249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22250 if (!SWIG_IsOK(res1)) {
22251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22252 }
22253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 {
22261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22262 }
22263 return resultobj;
22264 fail:
22265 return NULL;
22266 }
22267
22268
22269 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22270 PyObject *resultobj = 0;
22271 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22272 bool result;
22273 void *argp1 = 0 ;
22274 int res1 = 0 ;
22275 PyObject *swig_obj[1] ;
22276
22277 if (!args) SWIG_fail;
22278 swig_obj[0] = args;
22279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22282 }
22283 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22300 PyObject *resultobj = 0;
22301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22302 bool result;
22303 void *argp1 = 0 ;
22304 int res1 = 0 ;
22305 PyObject *swig_obj[1] ;
22306
22307 if (!args) SWIG_fail;
22308 swig_obj[0] = args;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22312 }
22313 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22332 int result;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_From_int(static_cast< int >(result));
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22358 PyObject *resultobj = 0;
22359 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22360 int result;
22361 void *argp1 = 0 ;
22362 int res1 = 0 ;
22363 PyObject *swig_obj[1] ;
22364
22365 if (!args) SWIG_fail;
22366 swig_obj[0] = args;
22367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22368 if (!SWIG_IsOK(res1)) {
22369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22370 }
22371 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 resultobj = SWIG_From_int(static_cast< int >(result));
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22386 PyObject *resultobj = 0;
22387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22388 int arg2 ;
22389 void *argp1 = 0 ;
22390 int res1 = 0 ;
22391 int val2 ;
22392 int ecode2 = 0 ;
22393 PyObject * obj0 = 0 ;
22394 PyObject * obj1 = 0 ;
22395 char * kwnames[] = {
22396 (char *) "self",(char *) "uniChar", NULL
22397 };
22398
22399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22401 if (!SWIG_IsOK(res1)) {
22402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22403 }
22404 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22405 ecode2 = SWIG_AsVal_int(obj1, &val2);
22406 if (!SWIG_IsOK(ecode2)) {
22407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22408 }
22409 arg2 = static_cast< int >(val2);
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 resultobj = SWIG_Py_Void();
22417 return resultobj;
22418 fail:
22419 return NULL;
22420 }
22421
22422
22423 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22424 PyObject *resultobj = 0;
22425 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22426 unsigned int result;
22427 void *argp1 = 0 ;
22428 int res1 = 0 ;
22429 PyObject *swig_obj[1] ;
22430
22431 if (!args) SWIG_fail;
22432 swig_obj[0] = args;
22433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22434 if (!SWIG_IsOK(res1)) {
22435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22436 }
22437 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22454 unsigned int result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 PyObject *swig_obj[1] ;
22458
22459 if (!args) SWIG_fail;
22460 swig_obj[0] = args;
22461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22464 }
22465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *resultobj = 0;
22481 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22482 wxPoint result;
22483 void *argp1 = 0 ;
22484 int res1 = 0 ;
22485 PyObject *swig_obj[1] ;
22486
22487 if (!args) SWIG_fail;
22488 swig_obj[0] = args;
22489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22492 }
22493 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22494 {
22495 PyThreadState* __tstate = wxPyBeginAllowThreads();
22496 result = (arg1)->GetPosition();
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22508 PyObject *resultobj = 0;
22509 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22510 long *arg2 = (long *) 0 ;
22511 long *arg3 = (long *) 0 ;
22512 void *argp1 = 0 ;
22513 int res1 = 0 ;
22514 long temp2 ;
22515 int res2 = SWIG_TMPOBJ ;
22516 long temp3 ;
22517 int res3 = SWIG_TMPOBJ ;
22518 PyObject *swig_obj[1] ;
22519
22520 arg2 = &temp2;
22521 arg3 = &temp3;
22522 if (!args) SWIG_fail;
22523 swig_obj[0] = args;
22524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22525 if (!SWIG_IsOK(res1)) {
22526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22527 }
22528 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22529 {
22530 PyThreadState* __tstate = wxPyBeginAllowThreads();
22531 (arg1)->GetPosition(arg2,arg3);
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 resultobj = SWIG_Py_Void();
22536 if (SWIG_IsTmpObj(res2)) {
22537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22538 } else {
22539 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22541 }
22542 if (SWIG_IsTmpObj(res3)) {
22543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22544 } else {
22545 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22547 }
22548 return resultobj;
22549 fail:
22550 return NULL;
22551 }
22552
22553
22554 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22555 PyObject *resultobj = 0;
22556 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22557 int result;
22558 void *argp1 = 0 ;
22559 int res1 = 0 ;
22560 PyObject *swig_obj[1] ;
22561
22562 if (!args) SWIG_fail;
22563 swig_obj[0] = args;
22564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22565 if (!SWIG_IsOK(res1)) {
22566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22567 }
22568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 result = (int)((wxKeyEvent const *)arg1)->GetX();
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 resultobj = SWIG_From_int(static_cast< int >(result));
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 int result;
22586 void *argp1 = 0 ;
22587 int res1 = 0 ;
22588 PyObject *swig_obj[1] ;
22589
22590 if (!args) SWIG_fail;
22591 swig_obj[0] = args;
22592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22595 }
22596 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22597 {
22598 PyThreadState* __tstate = wxPyBeginAllowThreads();
22599 result = (int)((wxKeyEvent const *)arg1)->GetY();
22600 wxPyEndAllowThreads(__tstate);
22601 if (PyErr_Occurred()) SWIG_fail;
22602 }
22603 resultobj = SWIG_From_int(static_cast< int >(result));
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22611 PyObject *resultobj = 0;
22612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22613 int arg2 ;
22614 void *argp1 = 0 ;
22615 int res1 = 0 ;
22616 int val2 ;
22617 int ecode2 = 0 ;
22618 PyObject *swig_obj[2] ;
22619
22620 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22622 if (!SWIG_IsOK(res1)) {
22623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22624 }
22625 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22626 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22627 if (!SWIG_IsOK(ecode2)) {
22628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22629 }
22630 arg2 = static_cast< int >(val2);
22631 if (arg1) (arg1)->m_x = arg2;
22632
22633 resultobj = SWIG_Py_Void();
22634 return resultobj;
22635 fail:
22636 return NULL;
22637 }
22638
22639
22640 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22641 PyObject *resultobj = 0;
22642 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22643 int result;
22644 void *argp1 = 0 ;
22645 int res1 = 0 ;
22646 PyObject *swig_obj[1] ;
22647
22648 if (!args) SWIG_fail;
22649 swig_obj[0] = args;
22650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22653 }
22654 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22655 result = (int) ((arg1)->m_x);
22656 resultobj = SWIG_From_int(static_cast< int >(result));
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22666 int arg2 ;
22667 void *argp1 = 0 ;
22668 int res1 = 0 ;
22669 int val2 ;
22670 int ecode2 = 0 ;
22671 PyObject *swig_obj[2] ;
22672
22673 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22675 if (!SWIG_IsOK(res1)) {
22676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22677 }
22678 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22679 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22680 if (!SWIG_IsOK(ecode2)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22682 }
22683 arg2 = static_cast< int >(val2);
22684 if (arg1) (arg1)->m_y = arg2;
22685
22686 resultobj = SWIG_Py_Void();
22687 return resultobj;
22688 fail:
22689 return NULL;
22690 }
22691
22692
22693 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22694 PyObject *resultobj = 0;
22695 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22696 int result;
22697 void *argp1 = 0 ;
22698 int res1 = 0 ;
22699 PyObject *swig_obj[1] ;
22700
22701 if (!args) SWIG_fail;
22702 swig_obj[0] = args;
22703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22704 if (!SWIG_IsOK(res1)) {
22705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22706 }
22707 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22708 result = (int) ((arg1)->m_y);
22709 resultobj = SWIG_From_int(static_cast< int >(result));
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 PyObject *resultobj = 0;
22718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22719 long arg2 ;
22720 void *argp1 = 0 ;
22721 int res1 = 0 ;
22722 long val2 ;
22723 int ecode2 = 0 ;
22724 PyObject *swig_obj[2] ;
22725
22726 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22732 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22733 if (!SWIG_IsOK(ecode2)) {
22734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22735 }
22736 arg2 = static_cast< long >(val2);
22737 if (arg1) (arg1)->m_keyCode = arg2;
22738
22739 resultobj = SWIG_Py_Void();
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *resultobj = 0;
22748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22749 long result;
22750 void *argp1 = 0 ;
22751 int res1 = 0 ;
22752 PyObject *swig_obj[1] ;
22753
22754 if (!args) SWIG_fail;
22755 swig_obj[0] = args;
22756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22757 if (!SWIG_IsOK(res1)) {
22758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22759 }
22760 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22761 result = (long) ((arg1)->m_keyCode);
22762 resultobj = SWIG_From_long(static_cast< long >(result));
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *resultobj = 0;
22771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22772 bool arg2 ;
22773 void *argp1 = 0 ;
22774 int res1 = 0 ;
22775 bool val2 ;
22776 int ecode2 = 0 ;
22777 PyObject *swig_obj[2] ;
22778
22779 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22781 if (!SWIG_IsOK(res1)) {
22782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22783 }
22784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22785 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22786 if (!SWIG_IsOK(ecode2)) {
22787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22788 }
22789 arg2 = static_cast< bool >(val2);
22790 if (arg1) (arg1)->m_controlDown = arg2;
22791
22792 resultobj = SWIG_Py_Void();
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22800 PyObject *resultobj = 0;
22801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22802 bool result;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 PyObject *swig_obj[1] ;
22806
22807 if (!args) SWIG_fail;
22808 swig_obj[0] = args;
22809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22810 if (!SWIG_IsOK(res1)) {
22811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22812 }
22813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22814 result = (bool) ((arg1)->m_controlDown);
22815 {
22816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22825 PyObject *resultobj = 0;
22826 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22827 bool arg2 ;
22828 void *argp1 = 0 ;
22829 int res1 = 0 ;
22830 bool val2 ;
22831 int ecode2 = 0 ;
22832 PyObject *swig_obj[2] ;
22833
22834 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22836 if (!SWIG_IsOK(res1)) {
22837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22838 }
22839 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22840 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22841 if (!SWIG_IsOK(ecode2)) {
22842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22843 }
22844 arg2 = static_cast< bool >(val2);
22845 if (arg1) (arg1)->m_shiftDown = arg2;
22846
22847 resultobj = SWIG_Py_Void();
22848 return resultobj;
22849 fail:
22850 return NULL;
22851 }
22852
22853
22854 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22855 PyObject *resultobj = 0;
22856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22857 bool result;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 PyObject *swig_obj[1] ;
22861
22862 if (!args) SWIG_fail;
22863 swig_obj[0] = args;
22864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22867 }
22868 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22869 result = (bool) ((arg1)->m_shiftDown);
22870 {
22871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22872 }
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22880 PyObject *resultobj = 0;
22881 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22882 bool arg2 ;
22883 void *argp1 = 0 ;
22884 int res1 = 0 ;
22885 bool val2 ;
22886 int ecode2 = 0 ;
22887 PyObject *swig_obj[2] ;
22888
22889 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22891 if (!SWIG_IsOK(res1)) {
22892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22893 }
22894 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22895 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22896 if (!SWIG_IsOK(ecode2)) {
22897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22898 }
22899 arg2 = static_cast< bool >(val2);
22900 if (arg1) (arg1)->m_altDown = arg2;
22901
22902 resultobj = SWIG_Py_Void();
22903 return resultobj;
22904 fail:
22905 return NULL;
22906 }
22907
22908
22909 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22910 PyObject *resultobj = 0;
22911 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22912 bool result;
22913 void *argp1 = 0 ;
22914 int res1 = 0 ;
22915 PyObject *swig_obj[1] ;
22916
22917 if (!args) SWIG_fail;
22918 swig_obj[0] = args;
22919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22920 if (!SWIG_IsOK(res1)) {
22921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22922 }
22923 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22924 result = (bool) ((arg1)->m_altDown);
22925 {
22926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22927 }
22928 return resultobj;
22929 fail:
22930 return NULL;
22931 }
22932
22933
22934 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22935 PyObject *resultobj = 0;
22936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22937 bool arg2 ;
22938 void *argp1 = 0 ;
22939 int res1 = 0 ;
22940 bool val2 ;
22941 int ecode2 = 0 ;
22942 PyObject *swig_obj[2] ;
22943
22944 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22946 if (!SWIG_IsOK(res1)) {
22947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22948 }
22949 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22950 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22951 if (!SWIG_IsOK(ecode2)) {
22952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22953 }
22954 arg2 = static_cast< bool >(val2);
22955 if (arg1) (arg1)->m_metaDown = arg2;
22956
22957 resultobj = SWIG_Py_Void();
22958 return resultobj;
22959 fail:
22960 return NULL;
22961 }
22962
22963
22964 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22965 PyObject *resultobj = 0;
22966 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22967 bool result;
22968 void *argp1 = 0 ;
22969 int res1 = 0 ;
22970 PyObject *swig_obj[1] ;
22971
22972 if (!args) SWIG_fail;
22973 swig_obj[0] = args;
22974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22975 if (!SWIG_IsOK(res1)) {
22976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22977 }
22978 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22979 result = (bool) ((arg1)->m_metaDown);
22980 {
22981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22982 }
22983 return resultobj;
22984 fail:
22985 return NULL;
22986 }
22987
22988
22989 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22990 PyObject *resultobj = 0;
22991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22992 bool arg2 ;
22993 void *argp1 = 0 ;
22994 int res1 = 0 ;
22995 bool val2 ;
22996 int ecode2 = 0 ;
22997 PyObject *swig_obj[2] ;
22998
22999 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23001 if (!SWIG_IsOK(res1)) {
23002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23003 }
23004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23005 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23006 if (!SWIG_IsOK(ecode2)) {
23007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23008 }
23009 arg2 = static_cast< bool >(val2);
23010 if (arg1) (arg1)->m_scanCode = arg2;
23011
23012 resultobj = SWIG_Py_Void();
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23020 PyObject *resultobj = 0;
23021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23022 bool result;
23023 void *argp1 = 0 ;
23024 int res1 = 0 ;
23025 PyObject *swig_obj[1] ;
23026
23027 if (!args) SWIG_fail;
23028 swig_obj[0] = args;
23029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23030 if (!SWIG_IsOK(res1)) {
23031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23032 }
23033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23034 result = (bool) ((arg1)->m_scanCode);
23035 {
23036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23037 }
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23045 PyObject *resultobj = 0;
23046 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23047 unsigned int arg2 ;
23048 void *argp1 = 0 ;
23049 int res1 = 0 ;
23050 unsigned int val2 ;
23051 int ecode2 = 0 ;
23052 PyObject *swig_obj[2] ;
23053
23054 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23056 if (!SWIG_IsOK(res1)) {
23057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23058 }
23059 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23060 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23061 if (!SWIG_IsOK(ecode2)) {
23062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23063 }
23064 arg2 = static_cast< unsigned int >(val2);
23065 if (arg1) (arg1)->m_rawCode = arg2;
23066
23067 resultobj = SWIG_Py_Void();
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23075 PyObject *resultobj = 0;
23076 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23077 unsigned int result;
23078 void *argp1 = 0 ;
23079 int res1 = 0 ;
23080 PyObject *swig_obj[1] ;
23081
23082 if (!args) SWIG_fail;
23083 swig_obj[0] = args;
23084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23085 if (!SWIG_IsOK(res1)) {
23086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23087 }
23088 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23089 result = (unsigned int) ((arg1)->m_rawCode);
23090 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 PyObject *resultobj = 0;
23099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23100 unsigned int arg2 ;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 unsigned int val2 ;
23104 int ecode2 = 0 ;
23105 PyObject *swig_obj[2] ;
23106
23107 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23109 if (!SWIG_IsOK(res1)) {
23110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23111 }
23112 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23113 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23114 if (!SWIG_IsOK(ecode2)) {
23115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23116 }
23117 arg2 = static_cast< unsigned int >(val2);
23118 if (arg1) (arg1)->m_rawFlags = arg2;
23119
23120 resultobj = SWIG_Py_Void();
23121 return resultobj;
23122 fail:
23123 return NULL;
23124 }
23125
23126
23127 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23128 PyObject *resultobj = 0;
23129 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23130 unsigned int result;
23131 void *argp1 = 0 ;
23132 int res1 = 0 ;
23133 PyObject *swig_obj[1] ;
23134
23135 if (!args) SWIG_fail;
23136 swig_obj[0] = args;
23137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23140 }
23141 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23142 result = (unsigned int) ((arg1)->m_rawFlags);
23143 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23151 PyObject *obj;
23152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23153 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23154 return SWIG_Py_Void();
23155 }
23156
23157 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 return SWIG_Python_InitShadowInstance(args);
23159 }
23160
23161 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23162 PyObject *resultobj = 0;
23163 wxSize const &arg1_defvalue = wxDefaultSize ;
23164 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23165 int arg2 = (int) 0 ;
23166 wxSizeEvent *result = 0 ;
23167 wxSize temp1 ;
23168 int val2 ;
23169 int ecode2 = 0 ;
23170 PyObject * obj0 = 0 ;
23171 PyObject * obj1 = 0 ;
23172 char * kwnames[] = {
23173 (char *) "sz",(char *) "winid", NULL
23174 };
23175
23176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23177 if (obj0) {
23178 {
23179 arg1 = &temp1;
23180 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23181 }
23182 }
23183 if (obj1) {
23184 ecode2 = SWIG_AsVal_int(obj1, &val2);
23185 if (!SWIG_IsOK(ecode2)) {
23186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23187 }
23188 arg2 = static_cast< int >(val2);
23189 }
23190 {
23191 PyThreadState* __tstate = wxPyBeginAllowThreads();
23192 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23193 wxPyEndAllowThreads(__tstate);
23194 if (PyErr_Occurred()) SWIG_fail;
23195 }
23196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23204 PyObject *resultobj = 0;
23205 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23206 wxSize result;
23207 void *argp1 = 0 ;
23208 int res1 = 0 ;
23209 PyObject *swig_obj[1] ;
23210
23211 if (!args) SWIG_fail;
23212 swig_obj[0] = args;
23213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23214 if (!SWIG_IsOK(res1)) {
23215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23216 }
23217 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = ((wxSizeEvent const *)arg1)->GetSize();
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 PyObject *resultobj = 0;
23233 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23234 wxRect result;
23235 void *argp1 = 0 ;
23236 int res1 = 0 ;
23237 PyObject *swig_obj[1] ;
23238
23239 if (!args) SWIG_fail;
23240 swig_obj[0] = args;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23244 }
23245 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = ((wxSizeEvent const *)arg1)->GetRect();
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23260 PyObject *resultobj = 0;
23261 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23262 wxRect arg2 ;
23263 void *argp1 = 0 ;
23264 int res1 = 0 ;
23265 void *argp2 ;
23266 int res2 = 0 ;
23267 PyObject * obj0 = 0 ;
23268 PyObject * obj1 = 0 ;
23269 char * kwnames[] = {
23270 (char *) "self",(char *) "rect", NULL
23271 };
23272
23273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23275 if (!SWIG_IsOK(res1)) {
23276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23277 }
23278 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23279 {
23280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23281 if (!SWIG_IsOK(res2)) {
23282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23283 }
23284 if (!argp2) {
23285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23286 } else {
23287 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23288 arg2 = *temp;
23289 if (SWIG_IsNewObj(res2)) delete temp;
23290 }
23291 }
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 (arg1)->SetRect(arg2);
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = SWIG_Py_Void();
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23308 wxSize arg2 ;
23309 void *argp1 = 0 ;
23310 int res1 = 0 ;
23311 void *argp2 ;
23312 int res2 = 0 ;
23313 PyObject * obj0 = 0 ;
23314 PyObject * obj1 = 0 ;
23315 char * kwnames[] = {
23316 (char *) "self",(char *) "size", NULL
23317 };
23318
23319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23321 if (!SWIG_IsOK(res1)) {
23322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23323 }
23324 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23325 {
23326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23327 if (!SWIG_IsOK(res2)) {
23328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23329 }
23330 if (!argp2) {
23331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23332 } else {
23333 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23334 arg2 = *temp;
23335 if (SWIG_IsNewObj(res2)) delete temp;
23336 }
23337 }
23338 {
23339 PyThreadState* __tstate = wxPyBeginAllowThreads();
23340 wxSizeEvent_SetSize(arg1,arg2);
23341 wxPyEndAllowThreads(__tstate);
23342 if (PyErr_Occurred()) SWIG_fail;
23343 }
23344 resultobj = SWIG_Py_Void();
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23352 PyObject *resultobj = 0;
23353 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23354 wxSize *arg2 = (wxSize *) 0 ;
23355 void *argp1 = 0 ;
23356 int res1 = 0 ;
23357 void *argp2 = 0 ;
23358 int res2 = 0 ;
23359 PyObject *swig_obj[2] ;
23360
23361 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23363 if (!SWIG_IsOK(res1)) {
23364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23365 }
23366 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23367 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23368 if (!SWIG_IsOK(res2)) {
23369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23370 }
23371 arg2 = reinterpret_cast< wxSize * >(argp2);
23372 if (arg1) (arg1)->m_size = *arg2;
23373
23374 resultobj = SWIG_Py_Void();
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23382 PyObject *resultobj = 0;
23383 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23384 wxSize *result = 0 ;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 PyObject *swig_obj[1] ;
23388
23389 if (!args) SWIG_fail;
23390 swig_obj[0] = args;
23391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23392 if (!SWIG_IsOK(res1)) {
23393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23394 }
23395 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23396 result = (wxSize *)& ((arg1)->m_size);
23397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23405 PyObject *resultobj = 0;
23406 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23407 wxRect *arg2 = (wxRect *) 0 ;
23408 void *argp1 = 0 ;
23409 int res1 = 0 ;
23410 void *argp2 = 0 ;
23411 int res2 = 0 ;
23412 PyObject *swig_obj[2] ;
23413
23414 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23416 if (!SWIG_IsOK(res1)) {
23417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23418 }
23419 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23420 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23421 if (!SWIG_IsOK(res2)) {
23422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23423 }
23424 arg2 = reinterpret_cast< wxRect * >(argp2);
23425 if (arg1) (arg1)->m_rect = *arg2;
23426
23427 resultobj = SWIG_Py_Void();
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 PyObject *resultobj = 0;
23436 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23437 wxRect *result = 0 ;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 PyObject *swig_obj[1] ;
23441
23442 if (!args) SWIG_fail;
23443 swig_obj[0] = args;
23444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23445 if (!SWIG_IsOK(res1)) {
23446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23447 }
23448 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23449 result = (wxRect *)& ((arg1)->m_rect);
23450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23458 PyObject *obj;
23459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23460 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23461 return SWIG_Py_Void();
23462 }
23463
23464 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23465 return SWIG_Python_InitShadowInstance(args);
23466 }
23467
23468 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23469 PyObject *resultobj = 0;
23470 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23471 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23472 int arg2 = (int) 0 ;
23473 wxMoveEvent *result = 0 ;
23474 wxPoint temp1 ;
23475 int val2 ;
23476 int ecode2 = 0 ;
23477 PyObject * obj0 = 0 ;
23478 PyObject * obj1 = 0 ;
23479 char * kwnames[] = {
23480 (char *) "pos",(char *) "winid", NULL
23481 };
23482
23483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23484 if (obj0) {
23485 {
23486 arg1 = &temp1;
23487 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23488 }
23489 }
23490 if (obj1) {
23491 ecode2 = SWIG_AsVal_int(obj1, &val2);
23492 if (!SWIG_IsOK(ecode2)) {
23493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23494 }
23495 arg2 = static_cast< int >(val2);
23496 }
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23500 wxPyEndAllowThreads(__tstate);
23501 if (PyErr_Occurred()) SWIG_fail;
23502 }
23503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23511 PyObject *resultobj = 0;
23512 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23513 wxPoint result;
23514 void *argp1 = 0 ;
23515 int res1 = 0 ;
23516 PyObject *swig_obj[1] ;
23517
23518 if (!args) SWIG_fail;
23519 swig_obj[0] = args;
23520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23521 if (!SWIG_IsOK(res1)) {
23522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23523 }
23524 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = ((wxMoveEvent const *)arg1)->GetPosition();
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23532 return resultobj;
23533 fail:
23534 return NULL;
23535 }
23536
23537
23538 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23539 PyObject *resultobj = 0;
23540 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23541 wxRect result;
23542 void *argp1 = 0 ;
23543 int res1 = 0 ;
23544 PyObject *swig_obj[1] ;
23545
23546 if (!args) SWIG_fail;
23547 swig_obj[0] = args;
23548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23549 if (!SWIG_IsOK(res1)) {
23550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23551 }
23552 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = ((wxMoveEvent const *)arg1)->GetRect();
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj = 0;
23568 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23569 wxRect *arg2 = 0 ;
23570 void *argp1 = 0 ;
23571 int res1 = 0 ;
23572 wxRect temp2 ;
23573 PyObject * obj0 = 0 ;
23574 PyObject * obj1 = 0 ;
23575 char * kwnames[] = {
23576 (char *) "self",(char *) "rect", NULL
23577 };
23578
23579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23581 if (!SWIG_IsOK(res1)) {
23582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23583 }
23584 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23585 {
23586 arg2 = &temp2;
23587 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23588 }
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 (arg1)->SetRect((wxRect const &)*arg2);
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 resultobj = SWIG_Py_Void();
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj = 0;
23604 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23605 wxPoint *arg2 = 0 ;
23606 void *argp1 = 0 ;
23607 int res1 = 0 ;
23608 wxPoint temp2 ;
23609 PyObject * obj0 = 0 ;
23610 PyObject * obj1 = 0 ;
23611 char * kwnames[] = {
23612 (char *) "self",(char *) "pos", NULL
23613 };
23614
23615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23619 }
23620 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23621 {
23622 arg2 = &temp2;
23623 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23624 }
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 (arg1)->SetPosition((wxPoint const &)*arg2);
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 resultobj = SWIG_Py_Void();
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *MoveEvent_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_wxMoveEvent, SWIG_NewClientData(obj));
23642 return SWIG_Py_Void();
23643 }
23644
23645 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 return SWIG_Python_InitShadowInstance(args);
23647 }
23648
23649 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 int arg1 = (int) 0 ;
23652 wxPaintEvent *result = 0 ;
23653 int val1 ;
23654 int ecode1 = 0 ;
23655 PyObject * obj0 = 0 ;
23656 char * kwnames[] = {
23657 (char *) "Id", NULL
23658 };
23659
23660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23661 if (obj0) {
23662 ecode1 = SWIG_AsVal_int(obj0, &val1);
23663 if (!SWIG_IsOK(ecode1)) {
23664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23665 }
23666 arg1 = static_cast< int >(val1);
23667 }
23668 {
23669 PyThreadState* __tstate = wxPyBeginAllowThreads();
23670 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23671 wxPyEndAllowThreads(__tstate);
23672 if (PyErr_Occurred()) SWIG_fail;
23673 }
23674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23682 PyObject *obj;
23683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23684 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23685 return SWIG_Py_Void();
23686 }
23687
23688 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23689 return SWIG_Python_InitShadowInstance(args);
23690 }
23691
23692 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23693 PyObject *resultobj = 0;
23694 int arg1 = (int) 0 ;
23695 wxNcPaintEvent *result = 0 ;
23696 int val1 ;
23697 int ecode1 = 0 ;
23698 PyObject * obj0 = 0 ;
23699 char * kwnames[] = {
23700 (char *) "winid", NULL
23701 };
23702
23703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23704 if (obj0) {
23705 ecode1 = SWIG_AsVal_int(obj0, &val1);
23706 if (!SWIG_IsOK(ecode1)) {
23707 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23708 }
23709 arg1 = static_cast< int >(val1);
23710 }
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23725 PyObject *obj;
23726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23727 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23728 return SWIG_Py_Void();
23729 }
23730
23731 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 return SWIG_Python_InitShadowInstance(args);
23733 }
23734
23735 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23736 PyObject *resultobj = 0;
23737 int arg1 = (int) 0 ;
23738 wxDC *arg2 = (wxDC *) NULL ;
23739 wxEraseEvent *result = 0 ;
23740 int val1 ;
23741 int ecode1 = 0 ;
23742 void *argp2 = 0 ;
23743 int res2 = 0 ;
23744 PyObject * obj0 = 0 ;
23745 PyObject * obj1 = 0 ;
23746 char * kwnames[] = {
23747 (char *) "Id",(char *) "dc", NULL
23748 };
23749
23750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23751 if (obj0) {
23752 ecode1 = SWIG_AsVal_int(obj0, &val1);
23753 if (!SWIG_IsOK(ecode1)) {
23754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23755 }
23756 arg1 = static_cast< int >(val1);
23757 }
23758 if (obj1) {
23759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23760 if (!SWIG_IsOK(res2)) {
23761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23762 }
23763 arg2 = reinterpret_cast< wxDC * >(argp2);
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23779 PyObject *resultobj = 0;
23780 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23781 wxDC *result = 0 ;
23782 void *argp1 = 0 ;
23783 int res1 = 0 ;
23784 PyObject *swig_obj[1] ;
23785
23786 if (!args) SWIG_fail;
23787 swig_obj[0] = args;
23788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23789 if (!SWIG_IsOK(res1)) {
23790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23791 }
23792 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23796 wxPyEndAllowThreads(__tstate);
23797 if (PyErr_Occurred()) SWIG_fail;
23798 }
23799 {
23800 resultobj = wxPyMake_wxObject(result, (bool)0);
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23822 int arg2 = (int) 0 ;
23823 wxFocusEvent *result = 0 ;
23824 int val1 ;
23825 int ecode1 = 0 ;
23826 int val2 ;
23827 int ecode2 = 0 ;
23828 PyObject * obj0 = 0 ;
23829 PyObject * obj1 = 0 ;
23830 char * kwnames[] = {
23831 (char *) "type",(char *) "winid", NULL
23832 };
23833
23834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23835 if (obj0) {
23836 ecode1 = SWIG_AsVal_int(obj0, &val1);
23837 if (!SWIG_IsOK(ecode1)) {
23838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23839 }
23840 arg1 = static_cast< wxEventType >(val1);
23841 }
23842 if (obj1) {
23843 ecode2 = SWIG_AsVal_int(obj1, &val2);
23844 if (!SWIG_IsOK(ecode2)) {
23845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23846 }
23847 arg2 = static_cast< int >(val2);
23848 }
23849 {
23850 PyThreadState* __tstate = wxPyBeginAllowThreads();
23851 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23852 wxPyEndAllowThreads(__tstate);
23853 if (PyErr_Occurred()) SWIG_fail;
23854 }
23855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23856 return resultobj;
23857 fail:
23858 return NULL;
23859 }
23860
23861
23862 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23863 PyObject *resultobj = 0;
23864 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23865 wxWindow *result = 0 ;
23866 void *argp1 = 0 ;
23867 int res1 = 0 ;
23868 PyObject *swig_obj[1] ;
23869
23870 if (!args) SWIG_fail;
23871 swig_obj[0] = args;
23872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23873 if (!SWIG_IsOK(res1)) {
23874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23875 }
23876 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23877 {
23878 PyThreadState* __tstate = wxPyBeginAllowThreads();
23879 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23880 wxPyEndAllowThreads(__tstate);
23881 if (PyErr_Occurred()) SWIG_fail;
23882 }
23883 {
23884 resultobj = wxPyMake_wxObject(result, (bool)0);
23885 }
23886 return resultobj;
23887 fail:
23888 return NULL;
23889 }
23890
23891
23892 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj = 0;
23894 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23895 wxWindow *arg2 = (wxWindow *) 0 ;
23896 void *argp1 = 0 ;
23897 int res1 = 0 ;
23898 void *argp2 = 0 ;
23899 int res2 = 0 ;
23900 PyObject * obj0 = 0 ;
23901 PyObject * obj1 = 0 ;
23902 char * kwnames[] = {
23903 (char *) "self",(char *) "win", NULL
23904 };
23905
23906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23908 if (!SWIG_IsOK(res1)) {
23909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23910 }
23911 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23912 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23913 if (!SWIG_IsOK(res2)) {
23914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23915 }
23916 arg2 = reinterpret_cast< wxWindow * >(argp2);
23917 {
23918 PyThreadState* __tstate = wxPyBeginAllowThreads();
23919 (arg1)->SetWindow(arg2);
23920 wxPyEndAllowThreads(__tstate);
23921 if (PyErr_Occurred()) SWIG_fail;
23922 }
23923 resultobj = SWIG_Py_Void();
23924 return resultobj;
23925 fail:
23926 return NULL;
23927 }
23928
23929
23930 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23931 PyObject *obj;
23932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23933 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23934 return SWIG_Py_Void();
23935 }
23936
23937 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23938 return SWIG_Python_InitShadowInstance(args);
23939 }
23940
23941 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23942 PyObject *resultobj = 0;
23943 wxWindow *arg1 = (wxWindow *) NULL ;
23944 wxChildFocusEvent *result = 0 ;
23945 void *argp1 = 0 ;
23946 int res1 = 0 ;
23947 PyObject * obj0 = 0 ;
23948 char * kwnames[] = {
23949 (char *) "win", NULL
23950 };
23951
23952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23953 if (obj0) {
23954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23955 if (!SWIG_IsOK(res1)) {
23956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23957 }
23958 arg1 = reinterpret_cast< wxWindow * >(argp1);
23959 }
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23974 PyObject *resultobj = 0;
23975 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23976 wxWindow *result = 0 ;
23977 void *argp1 = 0 ;
23978 int res1 = 0 ;
23979 PyObject *swig_obj[1] ;
23980
23981 if (!args) SWIG_fail;
23982 swig_obj[0] = args;
23983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23984 if (!SWIG_IsOK(res1)) {
23985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23986 }
23987 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23988 {
23989 PyThreadState* __tstate = wxPyBeginAllowThreads();
23990 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23991 wxPyEndAllowThreads(__tstate);
23992 if (PyErr_Occurred()) SWIG_fail;
23993 }
23994 {
23995 resultobj = wxPyMake_wxObject(result, (bool)0);
23996 }
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24004 PyObject *obj;
24005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24006 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24007 return SWIG_Py_Void();
24008 }
24009
24010 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24011 return SWIG_Python_InitShadowInstance(args);
24012 }
24013
24014 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24015 PyObject *resultobj = 0;
24016 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24017 bool arg2 = (bool) true ;
24018 int arg3 = (int) 0 ;
24019 wxActivateEvent *result = 0 ;
24020 int val1 ;
24021 int ecode1 = 0 ;
24022 bool val2 ;
24023 int ecode2 = 0 ;
24024 int val3 ;
24025 int ecode3 = 0 ;
24026 PyObject * obj0 = 0 ;
24027 PyObject * obj1 = 0 ;
24028 PyObject * obj2 = 0 ;
24029 char * kwnames[] = {
24030 (char *) "type",(char *) "active",(char *) "Id", NULL
24031 };
24032
24033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24034 if (obj0) {
24035 ecode1 = SWIG_AsVal_int(obj0, &val1);
24036 if (!SWIG_IsOK(ecode1)) {
24037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24038 }
24039 arg1 = static_cast< wxEventType >(val1);
24040 }
24041 if (obj1) {
24042 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24043 if (!SWIG_IsOK(ecode2)) {
24044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24045 }
24046 arg2 = static_cast< bool >(val2);
24047 }
24048 if (obj2) {
24049 ecode3 = SWIG_AsVal_int(obj2, &val3);
24050 if (!SWIG_IsOK(ecode3)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24052 }
24053 arg3 = static_cast< int >(val3);
24054 }
24055 {
24056 PyThreadState* __tstate = wxPyBeginAllowThreads();
24057 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24058 wxPyEndAllowThreads(__tstate);
24059 if (PyErr_Occurred()) SWIG_fail;
24060 }
24061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24069 PyObject *resultobj = 0;
24070 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24071 bool result;
24072 void *argp1 = 0 ;
24073 int res1 = 0 ;
24074 PyObject *swig_obj[1] ;
24075
24076 if (!args) SWIG_fail;
24077 swig_obj[0] = args;
24078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24079 if (!SWIG_IsOK(res1)) {
24080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24081 }
24082 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 {
24090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24091 }
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24099 PyObject *obj;
24100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24101 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24102 return SWIG_Py_Void();
24103 }
24104
24105 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24106 return SWIG_Python_InitShadowInstance(args);
24107 }
24108
24109 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24110 PyObject *resultobj = 0;
24111 int arg1 = (int) 0 ;
24112 wxInitDialogEvent *result = 0 ;
24113 int val1 ;
24114 int ecode1 = 0 ;
24115 PyObject * obj0 = 0 ;
24116 char * kwnames[] = {
24117 (char *) "Id", NULL
24118 };
24119
24120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24121 if (obj0) {
24122 ecode1 = SWIG_AsVal_int(obj0, &val1);
24123 if (!SWIG_IsOK(ecode1)) {
24124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24125 }
24126 arg1 = static_cast< int >(val1);
24127 }
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24135 return resultobj;
24136 fail:
24137 return NULL;
24138 }
24139
24140
24141 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24142 PyObject *obj;
24143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24144 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24145 return SWIG_Py_Void();
24146 }
24147
24148 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24149 return SWIG_Python_InitShadowInstance(args);
24150 }
24151
24152 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24153 PyObject *resultobj = 0;
24154 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24155 int arg2 = (int) 0 ;
24156 wxMenu *arg3 = (wxMenu *) NULL ;
24157 wxMenuEvent *result = 0 ;
24158 int val1 ;
24159 int ecode1 = 0 ;
24160 int val2 ;
24161 int ecode2 = 0 ;
24162 void *argp3 = 0 ;
24163 int res3 = 0 ;
24164 PyObject * obj0 = 0 ;
24165 PyObject * obj1 = 0 ;
24166 PyObject * obj2 = 0 ;
24167 char * kwnames[] = {
24168 (char *) "type",(char *) "winid",(char *) "menu", NULL
24169 };
24170
24171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24172 if (obj0) {
24173 ecode1 = SWIG_AsVal_int(obj0, &val1);
24174 if (!SWIG_IsOK(ecode1)) {
24175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24176 }
24177 arg1 = static_cast< wxEventType >(val1);
24178 }
24179 if (obj1) {
24180 ecode2 = SWIG_AsVal_int(obj1, &val2);
24181 if (!SWIG_IsOK(ecode2)) {
24182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24183 }
24184 arg2 = static_cast< int >(val2);
24185 }
24186 if (obj2) {
24187 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24188 if (!SWIG_IsOK(res3)) {
24189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24190 }
24191 arg3 = reinterpret_cast< wxMenu * >(argp3);
24192 }
24193 {
24194 PyThreadState* __tstate = wxPyBeginAllowThreads();
24195 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24207 PyObject *resultobj = 0;
24208 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24209 int result;
24210 void *argp1 = 0 ;
24211 int res1 = 0 ;
24212 PyObject *swig_obj[1] ;
24213
24214 if (!args) SWIG_fail;
24215 swig_obj[0] = args;
24216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24217 if (!SWIG_IsOK(res1)) {
24218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24219 }
24220 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 resultobj = SWIG_From_int(static_cast< int >(result));
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24235 PyObject *resultobj = 0;
24236 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24237 bool result;
24238 void *argp1 = 0 ;
24239 int res1 = 0 ;
24240 PyObject *swig_obj[1] ;
24241
24242 if (!args) SWIG_fail;
24243 swig_obj[0] = args;
24244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24245 if (!SWIG_IsOK(res1)) {
24246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24247 }
24248 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24252 wxPyEndAllowThreads(__tstate);
24253 if (PyErr_Occurred()) SWIG_fail;
24254 }
24255 {
24256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24257 }
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24267 wxMenu *result = 0 ;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24277 }
24278 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 resultobj = wxPyMake_wxObject(result, (bool)0);
24287 }
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *obj;
24296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24297 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24298 return SWIG_Py_Void();
24299 }
24300
24301 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24302 return SWIG_Python_InitShadowInstance(args);
24303 }
24304
24305 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj = 0;
24307 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24308 int arg2 = (int) 0 ;
24309 wxCloseEvent *result = 0 ;
24310 int val1 ;
24311 int ecode1 = 0 ;
24312 int val2 ;
24313 int ecode2 = 0 ;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 char * kwnames[] = {
24317 (char *) "type",(char *) "winid", NULL
24318 };
24319
24320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24321 if (obj0) {
24322 ecode1 = SWIG_AsVal_int(obj0, &val1);
24323 if (!SWIG_IsOK(ecode1)) {
24324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24325 }
24326 arg1 = static_cast< wxEventType >(val1);
24327 }
24328 if (obj1) {
24329 ecode2 = SWIG_AsVal_int(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24332 }
24333 arg2 = static_cast< int >(val2);
24334 }
24335 {
24336 PyThreadState* __tstate = wxPyBeginAllowThreads();
24337 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24338 wxPyEndAllowThreads(__tstate);
24339 if (PyErr_Occurred()) SWIG_fail;
24340 }
24341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj = 0;
24350 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24351 bool arg2 ;
24352 void *argp1 = 0 ;
24353 int res1 = 0 ;
24354 bool val2 ;
24355 int ecode2 = 0 ;
24356 PyObject * obj0 = 0 ;
24357 PyObject * obj1 = 0 ;
24358 char * kwnames[] = {
24359 (char *) "self",(char *) "logOff", NULL
24360 };
24361
24362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24364 if (!SWIG_IsOK(res1)) {
24365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24366 }
24367 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24369 if (!SWIG_IsOK(ecode2)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24371 }
24372 arg2 = static_cast< bool >(val2);
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 (arg1)->SetLoggingOff(arg2);
24376 wxPyEndAllowThreads(__tstate);
24377 if (PyErr_Occurred()) SWIG_fail;
24378 }
24379 resultobj = SWIG_Py_Void();
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *resultobj = 0;
24388 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24389 bool result;
24390 void *argp1 = 0 ;
24391 int res1 = 0 ;
24392 PyObject *swig_obj[1] ;
24393
24394 if (!args) SWIG_fail;
24395 swig_obj[0] = args;
24396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24397 if (!SWIG_IsOK(res1)) {
24398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24399 }
24400 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 {
24408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24409 }
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24417 PyObject *resultobj = 0;
24418 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24419 bool arg2 = (bool) true ;
24420 void *argp1 = 0 ;
24421 int res1 = 0 ;
24422 bool val2 ;
24423 int ecode2 = 0 ;
24424 PyObject * obj0 = 0 ;
24425 PyObject * obj1 = 0 ;
24426 char * kwnames[] = {
24427 (char *) "self",(char *) "veto", NULL
24428 };
24429
24430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24432 if (!SWIG_IsOK(res1)) {
24433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24434 }
24435 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24436 if (obj1) {
24437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24438 if (!SWIG_IsOK(ecode2)) {
24439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24440 }
24441 arg2 = static_cast< bool >(val2);
24442 }
24443 {
24444 PyThreadState* __tstate = wxPyBeginAllowThreads();
24445 (arg1)->Veto(arg2);
24446 wxPyEndAllowThreads(__tstate);
24447 if (PyErr_Occurred()) SWIG_fail;
24448 }
24449 resultobj = SWIG_Py_Void();
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24457 PyObject *resultobj = 0;
24458 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24459 bool result;
24460 void *argp1 = 0 ;
24461 int res1 = 0 ;
24462 PyObject *swig_obj[1] ;
24463
24464 if (!args) SWIG_fail;
24465 swig_obj[0] = args;
24466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24467 if (!SWIG_IsOK(res1)) {
24468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24469 }
24470 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24471 {
24472 PyThreadState* __tstate = wxPyBeginAllowThreads();
24473 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 {
24478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24479 }
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj = 0;
24488 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24489 bool arg2 ;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 bool val2 ;
24493 int ecode2 = 0 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 char * kwnames[] = {
24497 (char *) "self",(char *) "canVeto", NULL
24498 };
24499
24500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24504 }
24505 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24507 if (!SWIG_IsOK(ecode2)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24509 }
24510 arg2 = static_cast< bool >(val2);
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 (arg1)->SetCanVeto(arg2);
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_Py_Void();
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24527 bool result;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 PyObject *swig_obj[1] ;
24531
24532 if (!args) SWIG_fail;
24533 swig_obj[0] = args;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24537 }
24538 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24555 PyObject *obj;
24556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24557 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24558 return SWIG_Py_Void();
24559 }
24560
24561 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24562 return SWIG_Python_InitShadowInstance(args);
24563 }
24564
24565 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj = 0;
24567 int arg1 = (int) 0 ;
24568 bool arg2 = (bool) false ;
24569 wxShowEvent *result = 0 ;
24570 int val1 ;
24571 int ecode1 = 0 ;
24572 bool val2 ;
24573 int ecode2 = 0 ;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char * kwnames[] = {
24577 (char *) "winid",(char *) "show", NULL
24578 };
24579
24580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24581 if (obj0) {
24582 ecode1 = SWIG_AsVal_int(obj0, &val1);
24583 if (!SWIG_IsOK(ecode1)) {
24584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24585 }
24586 arg1 = static_cast< int >(val1);
24587 }
24588 if (obj1) {
24589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24592 }
24593 arg2 = static_cast< bool >(val2);
24594 }
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj = 0;
24610 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24611 bool arg2 ;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 bool val2 ;
24615 int ecode2 = 0 ;
24616 PyObject * obj0 = 0 ;
24617 PyObject * obj1 = 0 ;
24618 char * kwnames[] = {
24619 (char *) "self",(char *) "show", NULL
24620 };
24621
24622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24624 if (!SWIG_IsOK(res1)) {
24625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24626 }
24627 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24629 if (!SWIG_IsOK(ecode2)) {
24630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24631 }
24632 arg2 = static_cast< bool >(val2);
24633 {
24634 PyThreadState* __tstate = wxPyBeginAllowThreads();
24635 (arg1)->SetShow(arg2);
24636 wxPyEndAllowThreads(__tstate);
24637 if (PyErr_Occurred()) SWIG_fail;
24638 }
24639 resultobj = SWIG_Py_Void();
24640 return resultobj;
24641 fail:
24642 return NULL;
24643 }
24644
24645
24646 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24647 PyObject *resultobj = 0;
24648 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24649 bool result;
24650 void *argp1 = 0 ;
24651 int res1 = 0 ;
24652 PyObject *swig_obj[1] ;
24653
24654 if (!args) SWIG_fail;
24655 swig_obj[0] = args;
24656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24657 if (!SWIG_IsOK(res1)) {
24658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24659 }
24660 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24661 {
24662 PyThreadState* __tstate = wxPyBeginAllowThreads();
24663 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24664 wxPyEndAllowThreads(__tstate);
24665 if (PyErr_Occurred()) SWIG_fail;
24666 }
24667 {
24668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24669 }
24670 return resultobj;
24671 fail:
24672 return NULL;
24673 }
24674
24675
24676 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24677 PyObject *obj;
24678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24679 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24680 return SWIG_Py_Void();
24681 }
24682
24683 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24684 return SWIG_Python_InitShadowInstance(args);
24685 }
24686
24687 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj = 0;
24689 int arg1 = (int) 0 ;
24690 bool arg2 = (bool) true ;
24691 wxIconizeEvent *result = 0 ;
24692 int val1 ;
24693 int ecode1 = 0 ;
24694 bool val2 ;
24695 int ecode2 = 0 ;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 char * kwnames[] = {
24699 (char *) "id",(char *) "iconized", NULL
24700 };
24701
24702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24703 if (obj0) {
24704 ecode1 = SWIG_AsVal_int(obj0, &val1);
24705 if (!SWIG_IsOK(ecode1)) {
24706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24707 }
24708 arg1 = static_cast< int >(val1);
24709 }
24710 if (obj1) {
24711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24712 if (!SWIG_IsOK(ecode2)) {
24713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24714 }
24715 arg2 = static_cast< bool >(val2);
24716 }
24717 {
24718 PyThreadState* __tstate = wxPyBeginAllowThreads();
24719 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24731 PyObject *resultobj = 0;
24732 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24733 bool result;
24734 void *argp1 = 0 ;
24735 int res1 = 0 ;
24736 PyObject *swig_obj[1] ;
24737
24738 if (!args) SWIG_fail;
24739 swig_obj[0] = args;
24740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24741 if (!SWIG_IsOK(res1)) {
24742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24743 }
24744 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24745 {
24746 PyThreadState* __tstate = wxPyBeginAllowThreads();
24747 result = (bool)(arg1)->Iconized();
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 {
24752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24753 }
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24761 PyObject *obj;
24762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24763 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24764 return SWIG_Py_Void();
24765 }
24766
24767 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24768 return SWIG_Python_InitShadowInstance(args);
24769 }
24770
24771 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24772 PyObject *resultobj = 0;
24773 int arg1 = (int) 0 ;
24774 wxMaximizeEvent *result = 0 ;
24775 int val1 ;
24776 int ecode1 = 0 ;
24777 PyObject * obj0 = 0 ;
24778 char * kwnames[] = {
24779 (char *) "id", NULL
24780 };
24781
24782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24783 if (obj0) {
24784 ecode1 = SWIG_AsVal_int(obj0, &val1);
24785 if (!SWIG_IsOK(ecode1)) {
24786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24787 }
24788 arg1 = static_cast< int >(val1);
24789 }
24790 {
24791 PyThreadState* __tstate = wxPyBeginAllowThreads();
24792 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *obj;
24805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24806 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24807 return SWIG_Py_Void();
24808 }
24809
24810 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 return SWIG_Python_InitShadowInstance(args);
24812 }
24813
24814 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24815 PyObject *resultobj = 0;
24816 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24817 wxPoint result;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 PyObject *swig_obj[1] ;
24821
24822 if (!args) SWIG_fail;
24823 swig_obj[0] = args;
24824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24825 if (!SWIG_IsOK(res1)) {
24826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24827 }
24828 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24829 {
24830 PyThreadState* __tstate = wxPyBeginAllowThreads();
24831 result = (arg1)->GetPosition();
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 PyObject *resultobj = 0;
24844 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24845 int result;
24846 void *argp1 = 0 ;
24847 int res1 = 0 ;
24848 PyObject *swig_obj[1] ;
24849
24850 if (!args) SWIG_fail;
24851 swig_obj[0] = args;
24852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24855 }
24856 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = (int)(arg1)->GetNumberOfFiles();
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 resultobj = SWIG_From_int(static_cast< int >(result));
24864 return resultobj;
24865 fail:
24866 return NULL;
24867 }
24868
24869
24870 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24871 PyObject *resultobj = 0;
24872 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24873 PyObject *result = 0 ;
24874 void *argp1 = 0 ;
24875 int res1 = 0 ;
24876 PyObject *swig_obj[1] ;
24877
24878 if (!args) SWIG_fail;
24879 swig_obj[0] = args;
24880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24881 if (!SWIG_IsOK(res1)) {
24882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24883 }
24884 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 resultobj = result;
24892 return resultobj;
24893 fail:
24894 return NULL;
24895 }
24896
24897
24898 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24899 PyObject *obj;
24900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24901 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24902 return SWIG_Py_Void();
24903 }
24904
24905 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24906 PyObject *resultobj = 0;
24907 int arg1 = (int) 0 ;
24908 wxUpdateUIEvent *result = 0 ;
24909 int val1 ;
24910 int ecode1 = 0 ;
24911 PyObject * obj0 = 0 ;
24912 char * kwnames[] = {
24913 (char *) "commandId", NULL
24914 };
24915
24916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24917 if (obj0) {
24918 ecode1 = SWIG_AsVal_int(obj0, &val1);
24919 if (!SWIG_IsOK(ecode1)) {
24920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24921 }
24922 arg1 = static_cast< int >(val1);
24923 }
24924 {
24925 PyThreadState* __tstate = wxPyBeginAllowThreads();
24926 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24938 PyObject *resultobj = 0;
24939 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24940 bool result;
24941 void *argp1 = 0 ;
24942 int res1 = 0 ;
24943 PyObject *swig_obj[1] ;
24944
24945 if (!args) SWIG_fail;
24946 swig_obj[0] = args;
24947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24948 if (!SWIG_IsOK(res1)) {
24949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24950 }
24951 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24952 {
24953 PyThreadState* __tstate = wxPyBeginAllowThreads();
24954 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24955 wxPyEndAllowThreads(__tstate);
24956 if (PyErr_Occurred()) SWIG_fail;
24957 }
24958 {
24959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24960 }
24961 return resultobj;
24962 fail:
24963 return NULL;
24964 }
24965
24966
24967 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24968 PyObject *resultobj = 0;
24969 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24970 bool result;
24971 void *argp1 = 0 ;
24972 int res1 = 0 ;
24973 PyObject *swig_obj[1] ;
24974
24975 if (!args) SWIG_fail;
24976 swig_obj[0] = args;
24977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24978 if (!SWIG_IsOK(res1)) {
24979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24980 }
24981 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24982 {
24983 PyThreadState* __tstate = wxPyBeginAllowThreads();
24984 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24985 wxPyEndAllowThreads(__tstate);
24986 if (PyErr_Occurred()) SWIG_fail;
24987 }
24988 {
24989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24990 }
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24998 PyObject *resultobj = 0;
24999 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25000 bool result;
25001 void *argp1 = 0 ;
25002 int res1 = 0 ;
25003 PyObject *swig_obj[1] ;
25004
25005 if (!args) SWIG_fail;
25006 swig_obj[0] = args;
25007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25008 if (!SWIG_IsOK(res1)) {
25009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25010 }
25011 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25012 {
25013 PyThreadState* __tstate = wxPyBeginAllowThreads();
25014 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25015 wxPyEndAllowThreads(__tstate);
25016 if (PyErr_Occurred()) SWIG_fail;
25017 }
25018 {
25019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25020 }
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25028 PyObject *resultobj = 0;
25029 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25030 wxString result;
25031 void *argp1 = 0 ;
25032 int res1 = 0 ;
25033 PyObject *swig_obj[1] ;
25034
25035 if (!args) SWIG_fail;
25036 swig_obj[0] = args;
25037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25040 }
25041 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 #if wxUSE_UNICODE
25050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25051 #else
25052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25053 #endif
25054 }
25055 return resultobj;
25056 fail:
25057 return NULL;
25058 }
25059
25060
25061 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25062 PyObject *resultobj = 0;
25063 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25064 bool result;
25065 void *argp1 = 0 ;
25066 int res1 = 0 ;
25067 PyObject *swig_obj[1] ;
25068
25069 if (!args) SWIG_fail;
25070 swig_obj[0] = args;
25071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25072 if (!SWIG_IsOK(res1)) {
25073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25074 }
25075 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25076 {
25077 PyThreadState* __tstate = wxPyBeginAllowThreads();
25078 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25079 wxPyEndAllowThreads(__tstate);
25080 if (PyErr_Occurred()) SWIG_fail;
25081 }
25082 {
25083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25084 }
25085 return resultobj;
25086 fail:
25087 return NULL;
25088 }
25089
25090
25091 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25092 PyObject *resultobj = 0;
25093 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25094 bool result;
25095 void *argp1 = 0 ;
25096 int res1 = 0 ;
25097 PyObject *swig_obj[1] ;
25098
25099 if (!args) SWIG_fail;
25100 swig_obj[0] = args;
25101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25102 if (!SWIG_IsOK(res1)) {
25103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25104 }
25105 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25106 {
25107 PyThreadState* __tstate = wxPyBeginAllowThreads();
25108 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25109 wxPyEndAllowThreads(__tstate);
25110 if (PyErr_Occurred()) SWIG_fail;
25111 }
25112 {
25113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25114 }
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25122 PyObject *resultobj = 0;
25123 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25124 bool result;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 PyObject *swig_obj[1] ;
25128
25129 if (!args) SWIG_fail;
25130 swig_obj[0] = args;
25131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25134 }
25135 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 {
25143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25144 }
25145 return resultobj;
25146 fail:
25147 return NULL;
25148 }
25149
25150
25151 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25152 PyObject *resultobj = 0;
25153 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25154 bool result;
25155 void *argp1 = 0 ;
25156 int res1 = 0 ;
25157 PyObject *swig_obj[1] ;
25158
25159 if (!args) SWIG_fail;
25160 swig_obj[0] = args;
25161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25162 if (!SWIG_IsOK(res1)) {
25163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25164 }
25165 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25169 wxPyEndAllowThreads(__tstate);
25170 if (PyErr_Occurred()) SWIG_fail;
25171 }
25172 {
25173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25182 PyObject *resultobj = 0;
25183 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25184 bool arg2 ;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 bool val2 ;
25188 int ecode2 = 0 ;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 char * kwnames[] = {
25192 (char *) "self",(char *) "check", NULL
25193 };
25194
25195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25197 if (!SWIG_IsOK(res1)) {
25198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25199 }
25200 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25201 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25202 if (!SWIG_IsOK(ecode2)) {
25203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25204 }
25205 arg2 = static_cast< bool >(val2);
25206 {
25207 PyThreadState* __tstate = wxPyBeginAllowThreads();
25208 (arg1)->Check(arg2);
25209 wxPyEndAllowThreads(__tstate);
25210 if (PyErr_Occurred()) SWIG_fail;
25211 }
25212 resultobj = SWIG_Py_Void();
25213 return resultobj;
25214 fail:
25215 return NULL;
25216 }
25217
25218
25219 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25220 PyObject *resultobj = 0;
25221 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25222 bool arg2 ;
25223 void *argp1 = 0 ;
25224 int res1 = 0 ;
25225 bool val2 ;
25226 int ecode2 = 0 ;
25227 PyObject * obj0 = 0 ;
25228 PyObject * obj1 = 0 ;
25229 char * kwnames[] = {
25230 (char *) "self",(char *) "enable", NULL
25231 };
25232
25233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25235 if (!SWIG_IsOK(res1)) {
25236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25237 }
25238 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25239 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25240 if (!SWIG_IsOK(ecode2)) {
25241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25242 }
25243 arg2 = static_cast< bool >(val2);
25244 {
25245 PyThreadState* __tstate = wxPyBeginAllowThreads();
25246 (arg1)->Enable(arg2);
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 resultobj = SWIG_Py_Void();
25251 return resultobj;
25252 fail:
25253 return NULL;
25254 }
25255
25256
25257 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25258 PyObject *resultobj = 0;
25259 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25260 bool arg2 ;
25261 void *argp1 = 0 ;
25262 int res1 = 0 ;
25263 bool val2 ;
25264 int ecode2 = 0 ;
25265 PyObject * obj0 = 0 ;
25266 PyObject * obj1 = 0 ;
25267 char * kwnames[] = {
25268 (char *) "self",(char *) "show", NULL
25269 };
25270
25271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25275 }
25276 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25278 if (!SWIG_IsOK(ecode2)) {
25279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25280 }
25281 arg2 = static_cast< bool >(val2);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 (arg1)->Show(arg2);
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_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25296 PyObject *resultobj = 0;
25297 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25298 wxString *arg2 = 0 ;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 bool temp2 = false ;
25302 PyObject * obj0 = 0 ;
25303 PyObject * obj1 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "self",(char *) "text", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25310 if (!SWIG_IsOK(res1)) {
25311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25312 }
25313 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25314 {
25315 arg2 = wxString_in_helper(obj1);
25316 if (arg2 == NULL) SWIG_fail;
25317 temp2 = true;
25318 }
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 (arg1)->SetText((wxString const &)*arg2);
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 resultobj = SWIG_Py_Void();
25326 {
25327 if (temp2)
25328 delete arg2;
25329 }
25330 return resultobj;
25331 fail:
25332 {
25333 if (temp2)
25334 delete arg2;
25335 }
25336 return NULL;
25337 }
25338
25339
25340 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25341 PyObject *resultobj = 0;
25342 long arg1 ;
25343 long val1 ;
25344 int ecode1 = 0 ;
25345 PyObject * obj0 = 0 ;
25346 char * kwnames[] = {
25347 (char *) "updateInterval", NULL
25348 };
25349
25350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25351 ecode1 = SWIG_AsVal_long(obj0, &val1);
25352 if (!SWIG_IsOK(ecode1)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25354 }
25355 arg1 = static_cast< long >(val1);
25356 {
25357 PyThreadState* __tstate = wxPyBeginAllowThreads();
25358 wxUpdateUIEvent::SetUpdateInterval(arg1);
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 resultobj = SWIG_Py_Void();
25363 return resultobj;
25364 fail:
25365 return NULL;
25366 }
25367
25368
25369 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25370 PyObject *resultobj = 0;
25371 long result;
25372
25373 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25377 wxPyEndAllowThreads(__tstate);
25378 if (PyErr_Occurred()) SWIG_fail;
25379 }
25380 resultobj = SWIG_From_long(static_cast< long >(result));
25381 return resultobj;
25382 fail:
25383 return NULL;
25384 }
25385
25386
25387 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25388 PyObject *resultobj = 0;
25389 wxWindow *arg1 = (wxWindow *) 0 ;
25390 bool result;
25391 void *argp1 = 0 ;
25392 int res1 = 0 ;
25393 PyObject * obj0 = 0 ;
25394 char * kwnames[] = {
25395 (char *) "win", NULL
25396 };
25397
25398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25400 if (!SWIG_IsOK(res1)) {
25401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25402 }
25403 arg1 = reinterpret_cast< wxWindow * >(argp1);
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25407 wxPyEndAllowThreads(__tstate);
25408 if (PyErr_Occurred()) SWIG_fail;
25409 }
25410 {
25411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25412 }
25413 return resultobj;
25414 fail:
25415 return NULL;
25416 }
25417
25418
25419 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25420 PyObject *resultobj = 0;
25421
25422 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25423 {
25424 PyThreadState* __tstate = wxPyBeginAllowThreads();
25425 wxUpdateUIEvent::ResetUpdateTime();
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 resultobj = SWIG_Py_Void();
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj = 0;
25438 wxUpdateUIMode arg1 ;
25439 int val1 ;
25440 int ecode1 = 0 ;
25441 PyObject * obj0 = 0 ;
25442 char * kwnames[] = {
25443 (char *) "mode", NULL
25444 };
25445
25446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25447 ecode1 = SWIG_AsVal_int(obj0, &val1);
25448 if (!SWIG_IsOK(ecode1)) {
25449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25450 }
25451 arg1 = static_cast< wxUpdateUIMode >(val1);
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 wxUpdateUIEvent::SetMode(arg1);
25455 wxPyEndAllowThreads(__tstate);
25456 if (PyErr_Occurred()) SWIG_fail;
25457 }
25458 resultobj = SWIG_Py_Void();
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *resultobj = 0;
25467 wxUpdateUIMode result;
25468
25469 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 resultobj = SWIG_From_int(static_cast< int >(result));
25477 return resultobj;
25478 fail:
25479 return NULL;
25480 }
25481
25482
25483 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25484 PyObject *obj;
25485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25486 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25487 return SWIG_Py_Void();
25488 }
25489
25490 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25491 return SWIG_Python_InitShadowInstance(args);
25492 }
25493
25494 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxSysColourChangedEvent *result = 0 ;
25497
25498 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25513 PyObject *obj;
25514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25515 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25516 return SWIG_Py_Void();
25517 }
25518
25519 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25520 return SWIG_Python_InitShadowInstance(args);
25521 }
25522
25523 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25524 PyObject *resultobj = 0;
25525 int arg1 = (int) 0 ;
25526 wxWindow *arg2 = (wxWindow *) NULL ;
25527 wxMouseCaptureChangedEvent *result = 0 ;
25528 int val1 ;
25529 int ecode1 = 0 ;
25530 void *argp2 = 0 ;
25531 int res2 = 0 ;
25532 PyObject * obj0 = 0 ;
25533 PyObject * obj1 = 0 ;
25534 char * kwnames[] = {
25535 (char *) "winid",(char *) "gainedCapture", NULL
25536 };
25537
25538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25539 if (obj0) {
25540 ecode1 = SWIG_AsVal_int(obj0, &val1);
25541 if (!SWIG_IsOK(ecode1)) {
25542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25543 }
25544 arg1 = static_cast< int >(val1);
25545 }
25546 if (obj1) {
25547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25548 if (!SWIG_IsOK(res2)) {
25549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25550 }
25551 arg2 = reinterpret_cast< wxWindow * >(argp2);
25552 }
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25556 wxPyEndAllowThreads(__tstate);
25557 if (PyErr_Occurred()) SWIG_fail;
25558 }
25559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25560 return resultobj;
25561 fail:
25562 return NULL;
25563 }
25564
25565
25566 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25567 PyObject *resultobj = 0;
25568 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25569 wxWindow *result = 0 ;
25570 void *argp1 = 0 ;
25571 int res1 = 0 ;
25572 PyObject *swig_obj[1] ;
25573
25574 if (!args) SWIG_fail;
25575 swig_obj[0] = args;
25576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25577 if (!SWIG_IsOK(res1)) {
25578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25579 }
25580 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 {
25588 resultobj = wxPyMake_wxObject(result, (bool)0);
25589 }
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25597 PyObject *obj;
25598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25599 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25600 return SWIG_Py_Void();
25601 }
25602
25603 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25604 return SWIG_Python_InitShadowInstance(args);
25605 }
25606
25607 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25608 PyObject *resultobj = 0;
25609 int arg1 = (int) 0 ;
25610 wxMouseCaptureLostEvent *result = 0 ;
25611 int val1 ;
25612 int ecode1 = 0 ;
25613 PyObject * obj0 = 0 ;
25614 char * kwnames[] = {
25615 (char *) "winid", NULL
25616 };
25617
25618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25619 if (obj0) {
25620 ecode1 = SWIG_AsVal_int(obj0, &val1);
25621 if (!SWIG_IsOK(ecode1)) {
25622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25623 }
25624 arg1 = static_cast< int >(val1);
25625 }
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25640 PyObject *obj;
25641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25642 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25643 return SWIG_Py_Void();
25644 }
25645
25646 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 return SWIG_Python_InitShadowInstance(args);
25648 }
25649
25650 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25651 PyObject *resultobj = 0;
25652 wxDisplayChangedEvent *result = 0 ;
25653
25654 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25655 {
25656 PyThreadState* __tstate = wxPyBeginAllowThreads();
25657 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25669 PyObject *obj;
25670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25671 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25672 return SWIG_Py_Void();
25673 }
25674
25675 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 return SWIG_Python_InitShadowInstance(args);
25677 }
25678
25679 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25680 PyObject *resultobj = 0;
25681 int arg1 = (int) 0 ;
25682 wxPaletteChangedEvent *result = 0 ;
25683 int val1 ;
25684 int ecode1 = 0 ;
25685 PyObject * obj0 = 0 ;
25686 char * kwnames[] = {
25687 (char *) "id", NULL
25688 };
25689
25690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25691 if (obj0) {
25692 ecode1 = SWIG_AsVal_int(obj0, &val1);
25693 if (!SWIG_IsOK(ecode1)) {
25694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25695 }
25696 arg1 = static_cast< int >(val1);
25697 }
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25701 wxPyEndAllowThreads(__tstate);
25702 if (PyErr_Occurred()) SWIG_fail;
25703 }
25704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25705 return resultobj;
25706 fail:
25707 return NULL;
25708 }
25709
25710
25711 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25712 PyObject *resultobj = 0;
25713 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25714 wxWindow *arg2 = (wxWindow *) 0 ;
25715 void *argp1 = 0 ;
25716 int res1 = 0 ;
25717 void *argp2 = 0 ;
25718 int res2 = 0 ;
25719 PyObject * obj0 = 0 ;
25720 PyObject * obj1 = 0 ;
25721 char * kwnames[] = {
25722 (char *) "self",(char *) "win", NULL
25723 };
25724
25725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25727 if (!SWIG_IsOK(res1)) {
25728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25729 }
25730 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25732 if (!SWIG_IsOK(res2)) {
25733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25734 }
25735 arg2 = reinterpret_cast< wxWindow * >(argp2);
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 (arg1)->SetChangedWindow(arg2);
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 resultobj = SWIG_Py_Void();
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25752 wxWindow *result = 0 ;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25762 }
25763 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (wxWindow *)(arg1)->GetChangedWindow();
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 {
25771 resultobj = wxPyMake_wxObject(result, (bool)0);
25772 }
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25780 PyObject *obj;
25781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25782 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25783 return SWIG_Py_Void();
25784 }
25785
25786 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25787 return SWIG_Python_InitShadowInstance(args);
25788 }
25789
25790 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25791 PyObject *resultobj = 0;
25792 int arg1 = (int) 0 ;
25793 wxQueryNewPaletteEvent *result = 0 ;
25794 int val1 ;
25795 int ecode1 = 0 ;
25796 PyObject * obj0 = 0 ;
25797 char * kwnames[] = {
25798 (char *) "winid", NULL
25799 };
25800
25801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25802 if (obj0) {
25803 ecode1 = SWIG_AsVal_int(obj0, &val1);
25804 if (!SWIG_IsOK(ecode1)) {
25805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25806 }
25807 arg1 = static_cast< int >(val1);
25808 }
25809 {
25810 PyThreadState* __tstate = wxPyBeginAllowThreads();
25811 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25812 wxPyEndAllowThreads(__tstate);
25813 if (PyErr_Occurred()) SWIG_fail;
25814 }
25815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25823 PyObject *resultobj = 0;
25824 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25825 bool arg2 ;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 bool val2 ;
25829 int ecode2 = 0 ;
25830 PyObject * obj0 = 0 ;
25831 PyObject * obj1 = 0 ;
25832 char * kwnames[] = {
25833 (char *) "self",(char *) "realized", NULL
25834 };
25835
25836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25838 if (!SWIG_IsOK(res1)) {
25839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25840 }
25841 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25843 if (!SWIG_IsOK(ecode2)) {
25844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25845 }
25846 arg2 = static_cast< bool >(val2);
25847 {
25848 PyThreadState* __tstate = wxPyBeginAllowThreads();
25849 (arg1)->SetPaletteRealized(arg2);
25850 wxPyEndAllowThreads(__tstate);
25851 if (PyErr_Occurred()) SWIG_fail;
25852 }
25853 resultobj = SWIG_Py_Void();
25854 return resultobj;
25855 fail:
25856 return NULL;
25857 }
25858
25859
25860 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25861 PyObject *resultobj = 0;
25862 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25863 bool result;
25864 void *argp1 = 0 ;
25865 int res1 = 0 ;
25866 PyObject *swig_obj[1] ;
25867
25868 if (!args) SWIG_fail;
25869 swig_obj[0] = args;
25870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25871 if (!SWIG_IsOK(res1)) {
25872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25873 }
25874 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 {
25882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25883 }
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891 PyObject *obj;
25892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25893 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25894 return SWIG_Py_Void();
25895 }
25896
25897 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25898 return SWIG_Python_InitShadowInstance(args);
25899 }
25900
25901 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25902 PyObject *resultobj = 0;
25903 wxNavigationKeyEvent *result = 0 ;
25904
25905 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25920 PyObject *resultobj = 0;
25921 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25922 bool result;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 PyObject *swig_obj[1] ;
25926
25927 if (!args) SWIG_fail;
25928 swig_obj[0] = args;
25929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25930 if (!SWIG_IsOK(res1)) {
25931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25932 }
25933 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25937 wxPyEndAllowThreads(__tstate);
25938 if (PyErr_Occurred()) SWIG_fail;
25939 }
25940 {
25941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25942 }
25943 return resultobj;
25944 fail:
25945 return NULL;
25946 }
25947
25948
25949 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25950 PyObject *resultobj = 0;
25951 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25952 bool arg2 ;
25953 void *argp1 = 0 ;
25954 int res1 = 0 ;
25955 bool val2 ;
25956 int ecode2 = 0 ;
25957 PyObject * obj0 = 0 ;
25958 PyObject * obj1 = 0 ;
25959 char * kwnames[] = {
25960 (char *) "self",(char *) "forward", NULL
25961 };
25962
25963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25965 if (!SWIG_IsOK(res1)) {
25966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25967 }
25968 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25970 if (!SWIG_IsOK(ecode2)) {
25971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25972 }
25973 arg2 = static_cast< bool >(val2);
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 (arg1)->SetDirection(arg2);
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 resultobj = SWIG_Py_Void();
25981 return resultobj;
25982 fail:
25983 return NULL;
25984 }
25985
25986
25987 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988 PyObject *resultobj = 0;
25989 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25990 bool result;
25991 void *argp1 = 0 ;
25992 int res1 = 0 ;
25993 PyObject *swig_obj[1] ;
25994
25995 if (!args) SWIG_fail;
25996 swig_obj[0] = args;
25997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25998 if (!SWIG_IsOK(res1)) {
25999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26000 }
26001 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 {
26009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26010 }
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26018 PyObject *resultobj = 0;
26019 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26020 bool arg2 ;
26021 void *argp1 = 0 ;
26022 int res1 = 0 ;
26023 bool val2 ;
26024 int ecode2 = 0 ;
26025 PyObject * obj0 = 0 ;
26026 PyObject * obj1 = 0 ;
26027 char * kwnames[] = {
26028 (char *) "self",(char *) "ischange", NULL
26029 };
26030
26031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26033 if (!SWIG_IsOK(res1)) {
26034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26035 }
26036 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26037 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26038 if (!SWIG_IsOK(ecode2)) {
26039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26040 }
26041 arg2 = static_cast< bool >(val2);
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 (arg1)->SetWindowChange(arg2);
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_Py_Void();
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 PyObject *resultobj = 0;
26057 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26058 bool result;
26059 void *argp1 = 0 ;
26060 int res1 = 0 ;
26061 PyObject *swig_obj[1] ;
26062
26063 if (!args) SWIG_fail;
26064 swig_obj[0] = args;
26065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26068 }
26069 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 {
26077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26078 }
26079 return resultobj;
26080 fail:
26081 return NULL;
26082 }
26083
26084
26085 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj = 0;
26087 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26088 bool arg2 ;
26089 void *argp1 = 0 ;
26090 int res1 = 0 ;
26091 bool val2 ;
26092 int ecode2 = 0 ;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 char * kwnames[] = {
26096 (char *) "self",(char *) "bIs", NULL
26097 };
26098
26099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26101 if (!SWIG_IsOK(res1)) {
26102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26103 }
26104 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26105 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26106 if (!SWIG_IsOK(ecode2)) {
26107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26108 }
26109 arg2 = static_cast< bool >(val2);
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 (arg1)->SetFromTab(arg2);
26113 wxPyEndAllowThreads(__tstate);
26114 if (PyErr_Occurred()) SWIG_fail;
26115 }
26116 resultobj = SWIG_Py_Void();
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26124 PyObject *resultobj = 0;
26125 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26126 long arg2 ;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 long val2 ;
26130 int ecode2 = 0 ;
26131 PyObject * obj0 = 0 ;
26132 PyObject * obj1 = 0 ;
26133 char * kwnames[] = {
26134 (char *) "self",(char *) "flags", NULL
26135 };
26136
26137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26139 if (!SWIG_IsOK(res1)) {
26140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26141 }
26142 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26143 ecode2 = SWIG_AsVal_long(obj1, &val2);
26144 if (!SWIG_IsOK(ecode2)) {
26145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26146 }
26147 arg2 = static_cast< long >(val2);
26148 {
26149 PyThreadState* __tstate = wxPyBeginAllowThreads();
26150 (arg1)->SetFlags(arg2);
26151 wxPyEndAllowThreads(__tstate);
26152 if (PyErr_Occurred()) SWIG_fail;
26153 }
26154 resultobj = SWIG_Py_Void();
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26162 PyObject *resultobj = 0;
26163 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26164 wxWindow *result = 0 ;
26165 void *argp1 = 0 ;
26166 int res1 = 0 ;
26167 PyObject *swig_obj[1] ;
26168
26169 if (!args) SWIG_fail;
26170 swig_obj[0] = args;
26171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26172 if (!SWIG_IsOK(res1)) {
26173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26174 }
26175 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 {
26183 resultobj = wxPyMake_wxObject(result, (bool)0);
26184 }
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj = 0;
26193 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26194 wxWindow *arg2 = (wxWindow *) 0 ;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 void *argp2 = 0 ;
26198 int res2 = 0 ;
26199 PyObject * obj0 = 0 ;
26200 PyObject * obj1 = 0 ;
26201 char * kwnames[] = {
26202 (char *) "self",(char *) "win", NULL
26203 };
26204
26205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26207 if (!SWIG_IsOK(res1)) {
26208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26209 }
26210 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26212 if (!SWIG_IsOK(res2)) {
26213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26214 }
26215 arg2 = reinterpret_cast< wxWindow * >(argp2);
26216 {
26217 PyThreadState* __tstate = wxPyBeginAllowThreads();
26218 (arg1)->SetCurrentFocus(arg2);
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 resultobj = SWIG_Py_Void();
26223 return resultobj;
26224 fail:
26225 return NULL;
26226 }
26227
26228
26229 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26230 PyObject *obj;
26231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26232 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26233 return SWIG_Py_Void();
26234 }
26235
26236 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26237 return SWIG_Python_InitShadowInstance(args);
26238 }
26239
26240 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26241 PyObject *resultobj = 0;
26242 wxWindow *arg1 = (wxWindow *) NULL ;
26243 wxWindowCreateEvent *result = 0 ;
26244 void *argp1 = 0 ;
26245 int res1 = 0 ;
26246 PyObject * obj0 = 0 ;
26247 char * kwnames[] = {
26248 (char *) "win", NULL
26249 };
26250
26251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26252 if (obj0) {
26253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26254 if (!SWIG_IsOK(res1)) {
26255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26256 }
26257 arg1 = reinterpret_cast< wxWindow * >(argp1);
26258 }
26259 {
26260 PyThreadState* __tstate = wxPyBeginAllowThreads();
26261 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26266 return resultobj;
26267 fail:
26268 return NULL;
26269 }
26270
26271
26272 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26273 PyObject *resultobj = 0;
26274 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26275 wxWindow *result = 0 ;
26276 void *argp1 = 0 ;
26277 int res1 = 0 ;
26278 PyObject *swig_obj[1] ;
26279
26280 if (!args) SWIG_fail;
26281 swig_obj[0] = args;
26282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26283 if (!SWIG_IsOK(res1)) {
26284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26285 }
26286 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26287 {
26288 PyThreadState* __tstate = wxPyBeginAllowThreads();
26289 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26290 wxPyEndAllowThreads(__tstate);
26291 if (PyErr_Occurred()) SWIG_fail;
26292 }
26293 {
26294 resultobj = wxPyMake_wxObject(result, (bool)0);
26295 }
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *obj;
26304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26305 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26306 return SWIG_Py_Void();
26307 }
26308
26309 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26310 return SWIG_Python_InitShadowInstance(args);
26311 }
26312
26313 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj = 0;
26315 wxWindow *arg1 = (wxWindow *) NULL ;
26316 wxWindowDestroyEvent *result = 0 ;
26317 void *argp1 = 0 ;
26318 int res1 = 0 ;
26319 PyObject * obj0 = 0 ;
26320 char * kwnames[] = {
26321 (char *) "win", NULL
26322 };
26323
26324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26325 if (obj0) {
26326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26327 if (!SWIG_IsOK(res1)) {
26328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26329 }
26330 arg1 = reinterpret_cast< wxWindow * >(argp1);
26331 }
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26339 return resultobj;
26340 fail:
26341 return NULL;
26342 }
26343
26344
26345 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26346 PyObject *resultobj = 0;
26347 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26348 wxWindow *result = 0 ;
26349 void *argp1 = 0 ;
26350 int res1 = 0 ;
26351 PyObject *swig_obj[1] ;
26352
26353 if (!args) SWIG_fail;
26354 swig_obj[0] = args;
26355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26356 if (!SWIG_IsOK(res1)) {
26357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26358 }
26359 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 {
26367 resultobj = wxPyMake_wxObject(result, (bool)0);
26368 }
26369 return resultobj;
26370 fail:
26371 return NULL;
26372 }
26373
26374
26375 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26376 PyObject *obj;
26377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26378 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26379 return SWIG_Py_Void();
26380 }
26381
26382 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26383 return SWIG_Python_InitShadowInstance(args);
26384 }
26385
26386 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26387 PyObject *resultobj = 0;
26388 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26389 int arg2 = (int) 0 ;
26390 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26391 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26392 wxContextMenuEvent *result = 0 ;
26393 int val1 ;
26394 int ecode1 = 0 ;
26395 int val2 ;
26396 int ecode2 = 0 ;
26397 wxPoint temp3 ;
26398 PyObject * obj0 = 0 ;
26399 PyObject * obj1 = 0 ;
26400 PyObject * obj2 = 0 ;
26401 char * kwnames[] = {
26402 (char *) "type",(char *) "winid",(char *) "pt", NULL
26403 };
26404
26405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26406 if (obj0) {
26407 ecode1 = SWIG_AsVal_int(obj0, &val1);
26408 if (!SWIG_IsOK(ecode1)) {
26409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26410 }
26411 arg1 = static_cast< wxEventType >(val1);
26412 }
26413 if (obj1) {
26414 ecode2 = SWIG_AsVal_int(obj1, &val2);
26415 if (!SWIG_IsOK(ecode2)) {
26416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26417 }
26418 arg2 = static_cast< int >(val2);
26419 }
26420 if (obj2) {
26421 {
26422 arg3 = &temp3;
26423 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26424 }
26425 }
26426 {
26427 PyThreadState* __tstate = wxPyBeginAllowThreads();
26428 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26440 PyObject *resultobj = 0;
26441 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26442 wxPoint *result = 0 ;
26443 void *argp1 = 0 ;
26444 int res1 = 0 ;
26445 PyObject *swig_obj[1] ;
26446
26447 if (!args) SWIG_fail;
26448 swig_obj[0] = args;
26449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26450 if (!SWIG_IsOK(res1)) {
26451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26452 }
26453 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26454 {
26455 PyThreadState* __tstate = wxPyBeginAllowThreads();
26456 {
26457 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26458 result = (wxPoint *) &_result_ref;
26459 }
26460 wxPyEndAllowThreads(__tstate);
26461 if (PyErr_Occurred()) SWIG_fail;
26462 }
26463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26464 return resultobj;
26465 fail:
26466 return NULL;
26467 }
26468
26469
26470 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26471 PyObject *resultobj = 0;
26472 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26473 wxPoint *arg2 = 0 ;
26474 void *argp1 = 0 ;
26475 int res1 = 0 ;
26476 wxPoint temp2 ;
26477 PyObject * obj0 = 0 ;
26478 PyObject * obj1 = 0 ;
26479 char * kwnames[] = {
26480 (char *) "self",(char *) "pos", NULL
26481 };
26482
26483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26485 if (!SWIG_IsOK(res1)) {
26486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26487 }
26488 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26489 {
26490 arg2 = &temp2;
26491 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26492 }
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 (arg1)->SetPosition((wxPoint const &)*arg2);
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_Py_Void();
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26507 PyObject *obj;
26508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26509 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26510 return SWIG_Py_Void();
26511 }
26512
26513 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26514 return SWIG_Python_InitShadowInstance(args);
26515 }
26516
26517 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518 PyObject *resultobj = 0;
26519 wxIdleEvent *result = 0 ;
26520
26521 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26522 {
26523 PyThreadState* __tstate = wxPyBeginAllowThreads();
26524 result = (wxIdleEvent *)new wxIdleEvent();
26525 wxPyEndAllowThreads(__tstate);
26526 if (PyErr_Occurred()) SWIG_fail;
26527 }
26528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26529 return resultobj;
26530 fail:
26531 return NULL;
26532 }
26533
26534
26535 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26536 PyObject *resultobj = 0;
26537 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26538 bool arg2 = (bool) true ;
26539 void *argp1 = 0 ;
26540 int res1 = 0 ;
26541 bool val2 ;
26542 int ecode2 = 0 ;
26543 PyObject * obj0 = 0 ;
26544 PyObject * obj1 = 0 ;
26545 char * kwnames[] = {
26546 (char *) "self",(char *) "needMore", NULL
26547 };
26548
26549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26551 if (!SWIG_IsOK(res1)) {
26552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26553 }
26554 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26555 if (obj1) {
26556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26557 if (!SWIG_IsOK(ecode2)) {
26558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26559 }
26560 arg2 = static_cast< bool >(val2);
26561 }
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 (arg1)->RequestMore(arg2);
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 resultobj = SWIG_Py_Void();
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26576 PyObject *resultobj = 0;
26577 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26578 bool result;
26579 void *argp1 = 0 ;
26580 int res1 = 0 ;
26581 PyObject *swig_obj[1] ;
26582
26583 if (!args) SWIG_fail;
26584 swig_obj[0] = args;
26585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26586 if (!SWIG_IsOK(res1)) {
26587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26588 }
26589 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 {
26597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26598 }
26599 return resultobj;
26600 fail:
26601 return NULL;
26602 }
26603
26604
26605 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26606 PyObject *resultobj = 0;
26607 wxIdleMode arg1 ;
26608 int val1 ;
26609 int ecode1 = 0 ;
26610 PyObject * obj0 = 0 ;
26611 char * kwnames[] = {
26612 (char *) "mode", NULL
26613 };
26614
26615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26616 ecode1 = SWIG_AsVal_int(obj0, &val1);
26617 if (!SWIG_IsOK(ecode1)) {
26618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26619 }
26620 arg1 = static_cast< wxIdleMode >(val1);
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 wxIdleEvent::SetMode(arg1);
26624 wxPyEndAllowThreads(__tstate);
26625 if (PyErr_Occurred()) SWIG_fail;
26626 }
26627 resultobj = SWIG_Py_Void();
26628 return resultobj;
26629 fail:
26630 return NULL;
26631 }
26632
26633
26634 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26635 PyObject *resultobj = 0;
26636 wxIdleMode result;
26637
26638 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (wxIdleMode)wxIdleEvent::GetMode();
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = SWIG_From_int(static_cast< int >(result));
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26653 PyObject *resultobj = 0;
26654 wxWindow *arg1 = (wxWindow *) 0 ;
26655 bool result;
26656 void *argp1 = 0 ;
26657 int res1 = 0 ;
26658 PyObject * obj0 = 0 ;
26659 char * kwnames[] = {
26660 (char *) "win", NULL
26661 };
26662
26663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26665 if (!SWIG_IsOK(res1)) {
26666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26667 }
26668 arg1 = reinterpret_cast< wxWindow * >(argp1);
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 result = (bool)wxIdleEvent::CanSend(arg1);
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 {
26676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26677 }
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26685 PyObject *obj;
26686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26687 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26688 return SWIG_Py_Void();
26689 }
26690
26691 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26692 return SWIG_Python_InitShadowInstance(args);
26693 }
26694
26695 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26696 PyObject *resultobj = 0;
26697 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26698 int arg2 = (int) 0 ;
26699 wxClipboardTextEvent *result = 0 ;
26700 int val1 ;
26701 int ecode1 = 0 ;
26702 int val2 ;
26703 int ecode2 = 0 ;
26704 PyObject * obj0 = 0 ;
26705 PyObject * obj1 = 0 ;
26706 char * kwnames[] = {
26707 (char *) "type",(char *) "winid", NULL
26708 };
26709
26710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26711 if (obj0) {
26712 ecode1 = SWIG_AsVal_int(obj0, &val1);
26713 if (!SWIG_IsOK(ecode1)) {
26714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26715 }
26716 arg1 = static_cast< wxEventType >(val1);
26717 }
26718 if (obj1) {
26719 ecode2 = SWIG_AsVal_int(obj1, &val2);
26720 if (!SWIG_IsOK(ecode2)) {
26721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26722 }
26723 arg2 = static_cast< int >(val2);
26724 }
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26739 PyObject *obj;
26740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26741 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26742 return SWIG_Py_Void();
26743 }
26744
26745 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26746 return SWIG_Python_InitShadowInstance(args);
26747 }
26748
26749 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 int arg1 = (int) 0 ;
26752 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26753 wxPyEvent *result = 0 ;
26754 int val1 ;
26755 int ecode1 = 0 ;
26756 int val2 ;
26757 int ecode2 = 0 ;
26758 PyObject * obj0 = 0 ;
26759 PyObject * obj1 = 0 ;
26760 char * kwnames[] = {
26761 (char *) "winid",(char *) "eventType", NULL
26762 };
26763
26764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26765 if (obj0) {
26766 ecode1 = SWIG_AsVal_int(obj0, &val1);
26767 if (!SWIG_IsOK(ecode1)) {
26768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26769 }
26770 arg1 = static_cast< int >(val1);
26771 }
26772 if (obj1) {
26773 ecode2 = SWIG_AsVal_int(obj1, &val2);
26774 if (!SWIG_IsOK(ecode2)) {
26775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26776 }
26777 arg2 = static_cast< wxEventType >(val2);
26778 }
26779 {
26780 PyThreadState* __tstate = wxPyBeginAllowThreads();
26781 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26782 wxPyEndAllowThreads(__tstate);
26783 if (PyErr_Occurred()) SWIG_fail;
26784 }
26785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26793 PyObject *resultobj = 0;
26794 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26795 void *argp1 = 0 ;
26796 int res1 = 0 ;
26797 PyObject *swig_obj[1] ;
26798
26799 if (!args) SWIG_fail;
26800 swig_obj[0] = args;
26801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26802 if (!SWIG_IsOK(res1)) {
26803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26804 }
26805 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 delete arg1;
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 resultobj = SWIG_Py_Void();
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj = 0;
26822 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26823 PyObject *arg2 = (PyObject *) 0 ;
26824 void *argp1 = 0 ;
26825 int res1 = 0 ;
26826 PyObject * obj0 = 0 ;
26827 PyObject * obj1 = 0 ;
26828 char * kwnames[] = {
26829 (char *) "self",(char *) "self", NULL
26830 };
26831
26832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26834 if (!SWIG_IsOK(res1)) {
26835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26836 }
26837 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26838 arg2 = obj1;
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 (arg1)->SetSelf(arg2);
26842 wxPyEndAllowThreads(__tstate);
26843 if (PyErr_Occurred()) SWIG_fail;
26844 }
26845 resultobj = SWIG_Py_Void();
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26853 PyObject *resultobj = 0;
26854 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26855 PyObject *result = 0 ;
26856 void *argp1 = 0 ;
26857 int res1 = 0 ;
26858 PyObject *swig_obj[1] ;
26859
26860 if (!args) SWIG_fail;
26861 swig_obj[0] = args;
26862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26863 if (!SWIG_IsOK(res1)) {
26864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26865 }
26866 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26867 {
26868 PyThreadState* __tstate = wxPyBeginAllowThreads();
26869 result = (PyObject *)(arg1)->GetSelf();
26870 wxPyEndAllowThreads(__tstate);
26871 if (PyErr_Occurred()) SWIG_fail;
26872 }
26873 resultobj = result;
26874 return resultobj;
26875 fail:
26876 return NULL;
26877 }
26878
26879
26880 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26881 PyObject *obj;
26882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26883 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26884 return SWIG_Py_Void();
26885 }
26886
26887 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 return SWIG_Python_InitShadowInstance(args);
26889 }
26890
26891 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26892 PyObject *resultobj = 0;
26893 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26894 int arg2 = (int) 0 ;
26895 wxPyCommandEvent *result = 0 ;
26896 int val1 ;
26897 int ecode1 = 0 ;
26898 int val2 ;
26899 int ecode2 = 0 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 char * kwnames[] = {
26903 (char *) "eventType",(char *) "id", NULL
26904 };
26905
26906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26907 if (obj0) {
26908 ecode1 = SWIG_AsVal_int(obj0, &val1);
26909 if (!SWIG_IsOK(ecode1)) {
26910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26911 }
26912 arg1 = static_cast< wxEventType >(val1);
26913 }
26914 if (obj1) {
26915 ecode2 = SWIG_AsVal_int(obj1, &val2);
26916 if (!SWIG_IsOK(ecode2)) {
26917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26918 }
26919 arg2 = static_cast< int >(val2);
26920 }
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26928 return resultobj;
26929 fail:
26930 return NULL;
26931 }
26932
26933
26934 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26935 PyObject *resultobj = 0;
26936 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26937 void *argp1 = 0 ;
26938 int res1 = 0 ;
26939 PyObject *swig_obj[1] ;
26940
26941 if (!args) SWIG_fail;
26942 swig_obj[0] = args;
26943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26944 if (!SWIG_IsOK(res1)) {
26945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26946 }
26947 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26948 {
26949 PyThreadState* __tstate = wxPyBeginAllowThreads();
26950 delete arg1;
26951
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 resultobj = SWIG_Py_Void();
26956 return resultobj;
26957 fail:
26958 return NULL;
26959 }
26960
26961
26962 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26963 PyObject *resultobj = 0;
26964 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26965 PyObject *arg2 = (PyObject *) 0 ;
26966 void *argp1 = 0 ;
26967 int res1 = 0 ;
26968 PyObject * obj0 = 0 ;
26969 PyObject * obj1 = 0 ;
26970 char * kwnames[] = {
26971 (char *) "self",(char *) "self", NULL
26972 };
26973
26974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26976 if (!SWIG_IsOK(res1)) {
26977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26978 }
26979 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26980 arg2 = obj1;
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 (arg1)->SetSelf(arg2);
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 resultobj = SWIG_Py_Void();
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26995 PyObject *resultobj = 0;
26996 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26997 PyObject *result = 0 ;
26998 void *argp1 = 0 ;
26999 int res1 = 0 ;
27000 PyObject *swig_obj[1] ;
27001
27002 if (!args) SWIG_fail;
27003 swig_obj[0] = args;
27004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27007 }
27008 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 result = (PyObject *)(arg1)->GetSelf();
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 resultobj = result;
27016 return resultobj;
27017 fail:
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27023 PyObject *obj;
27024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27025 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27026 return SWIG_Py_Void();
27027 }
27028
27029 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27030 return SWIG_Python_InitShadowInstance(args);
27031 }
27032
27033 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27034 PyObject *resultobj = 0;
27035 wxWindow *arg1 = (wxWindow *) 0 ;
27036 wxDateTime *arg2 = 0 ;
27037 wxEventType arg3 ;
27038 wxDateEvent *result = 0 ;
27039 void *argp1 = 0 ;
27040 int res1 = 0 ;
27041 void *argp2 = 0 ;
27042 int res2 = 0 ;
27043 int val3 ;
27044 int ecode3 = 0 ;
27045 PyObject * obj0 = 0 ;
27046 PyObject * obj1 = 0 ;
27047 PyObject * obj2 = 0 ;
27048 char * kwnames[] = {
27049 (char *) "win",(char *) "dt",(char *) "type", NULL
27050 };
27051
27052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27054 if (!SWIG_IsOK(res1)) {
27055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27056 }
27057 arg1 = reinterpret_cast< wxWindow * >(argp1);
27058 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27059 if (!SWIG_IsOK(res2)) {
27060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27061 }
27062 if (!argp2) {
27063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27064 }
27065 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27066 ecode3 = SWIG_AsVal_int(obj2, &val3);
27067 if (!SWIG_IsOK(ecode3)) {
27068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27069 }
27070 arg3 = static_cast< wxEventType >(val3);
27071 {
27072 PyThreadState* __tstate = wxPyBeginAllowThreads();
27073 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27074 wxPyEndAllowThreads(__tstate);
27075 if (PyErr_Occurred()) SWIG_fail;
27076 }
27077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27085 PyObject *resultobj = 0;
27086 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27087 wxDateTime *result = 0 ;
27088 void *argp1 = 0 ;
27089 int res1 = 0 ;
27090 PyObject *swig_obj[1] ;
27091
27092 if (!args) SWIG_fail;
27093 swig_obj[0] = args;
27094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27095 if (!SWIG_IsOK(res1)) {
27096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27097 }
27098 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27099 {
27100 PyThreadState* __tstate = wxPyBeginAllowThreads();
27101 {
27102 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27103 result = (wxDateTime *) &_result_ref;
27104 }
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27109 return resultobj;
27110 fail:
27111 return NULL;
27112 }
27113
27114
27115 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27116 PyObject *resultobj = 0;
27117 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27118 wxDateTime *arg2 = 0 ;
27119 void *argp1 = 0 ;
27120 int res1 = 0 ;
27121 void *argp2 = 0 ;
27122 int res2 = 0 ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char * kwnames[] = {
27126 (char *) "self",(char *) "date", NULL
27127 };
27128
27129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27133 }
27134 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27136 if (!SWIG_IsOK(res2)) {
27137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27138 }
27139 if (!argp2) {
27140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27141 }
27142 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27143 {
27144 PyThreadState* __tstate = wxPyBeginAllowThreads();
27145 (arg1)->SetDate((wxDateTime const &)*arg2);
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 resultobj = SWIG_Py_Void();
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27157 PyObject *obj;
27158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27159 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27160 return SWIG_Py_Void();
27161 }
27162
27163 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 return SWIG_Python_InitShadowInstance(args);
27165 }
27166
27167 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27168 PyObject *resultobj = 0;
27169 wxPyApp *result = 0 ;
27170
27171 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27172 {
27173 PyThreadState* __tstate = wxPyBeginAllowThreads();
27174 result = (wxPyApp *)new_wxPyApp();
27175 wxPyEndAllowThreads(__tstate);
27176 if (PyErr_Occurred()) SWIG_fail;
27177 }
27178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27186 PyObject *resultobj = 0;
27187 wxPyApp *arg1 = (wxPyApp *) 0 ;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 PyObject *swig_obj[1] ;
27191
27192 if (!args) SWIG_fail;
27193 swig_obj[0] = args;
27194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27195 if (!SWIG_IsOK(res1)) {
27196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27197 }
27198 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27199 {
27200 PyThreadState* __tstate = wxPyBeginAllowThreads();
27201 delete arg1;
27202
27203 wxPyEndAllowThreads(__tstate);
27204 if (PyErr_Occurred()) SWIG_fail;
27205 }
27206 resultobj = SWIG_Py_Void();
27207 return resultobj;
27208 fail:
27209 return NULL;
27210 }
27211
27212
27213 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27214 PyObject *resultobj = 0;
27215 wxPyApp *arg1 = (wxPyApp *) 0 ;
27216 PyObject *arg2 = (PyObject *) 0 ;
27217 PyObject *arg3 = (PyObject *) 0 ;
27218 bool arg4 ;
27219 void *argp1 = 0 ;
27220 int res1 = 0 ;
27221 bool val4 ;
27222 int ecode4 = 0 ;
27223 PyObject * obj0 = 0 ;
27224 PyObject * obj1 = 0 ;
27225 PyObject * obj2 = 0 ;
27226 PyObject * obj3 = 0 ;
27227 char * kwnames[] = {
27228 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27229 };
27230
27231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27233 if (!SWIG_IsOK(res1)) {
27234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27235 }
27236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27237 arg2 = obj1;
27238 arg3 = obj2;
27239 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27240 if (!SWIG_IsOK(ecode4)) {
27241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27242 }
27243 arg4 = static_cast< bool >(val4);
27244 {
27245 PyThreadState* __tstate = wxPyBeginAllowThreads();
27246 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27247 wxPyEndAllowThreads(__tstate);
27248 if (PyErr_Occurred()) SWIG_fail;
27249 }
27250 resultobj = SWIG_Py_Void();
27251 return resultobj;
27252 fail:
27253 return NULL;
27254 }
27255
27256
27257 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27258 PyObject *resultobj = 0;
27259 wxPyApp *arg1 = (wxPyApp *) 0 ;
27260 wxString result;
27261 void *argp1 = 0 ;
27262 int res1 = 0 ;
27263 PyObject *swig_obj[1] ;
27264
27265 if (!args) SWIG_fail;
27266 swig_obj[0] = args;
27267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27268 if (!SWIG_IsOK(res1)) {
27269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27270 }
27271 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27272 {
27273 PyThreadState* __tstate = wxPyBeginAllowThreads();
27274 result = ((wxPyApp const *)arg1)->GetAppName();
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 {
27279 #if wxUSE_UNICODE
27280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27281 #else
27282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27283 #endif
27284 }
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27292 PyObject *resultobj = 0;
27293 wxPyApp *arg1 = (wxPyApp *) 0 ;
27294 wxString *arg2 = 0 ;
27295 void *argp1 = 0 ;
27296 int res1 = 0 ;
27297 bool temp2 = false ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 char * kwnames[] = {
27301 (char *) "self",(char *) "name", NULL
27302 };
27303
27304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27306 if (!SWIG_IsOK(res1)) {
27307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27308 }
27309 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27310 {
27311 arg2 = wxString_in_helper(obj1);
27312 if (arg2 == NULL) SWIG_fail;
27313 temp2 = true;
27314 }
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 (arg1)->SetAppName((wxString const &)*arg2);
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 resultobj = SWIG_Py_Void();
27322 {
27323 if (temp2)
27324 delete arg2;
27325 }
27326 return resultobj;
27327 fail:
27328 {
27329 if (temp2)
27330 delete arg2;
27331 }
27332 return NULL;
27333 }
27334
27335
27336 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27337 PyObject *resultobj = 0;
27338 wxPyApp *arg1 = (wxPyApp *) 0 ;
27339 wxString result;
27340 void *argp1 = 0 ;
27341 int res1 = 0 ;
27342 PyObject *swig_obj[1] ;
27343
27344 if (!args) SWIG_fail;
27345 swig_obj[0] = args;
27346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27347 if (!SWIG_IsOK(res1)) {
27348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27349 }
27350 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 result = ((wxPyApp const *)arg1)->GetClassName();
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 {
27358 #if wxUSE_UNICODE
27359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27360 #else
27361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27362 #endif
27363 }
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27371 PyObject *resultobj = 0;
27372 wxPyApp *arg1 = (wxPyApp *) 0 ;
27373 wxString *arg2 = 0 ;
27374 void *argp1 = 0 ;
27375 int res1 = 0 ;
27376 bool temp2 = false ;
27377 PyObject * obj0 = 0 ;
27378 PyObject * obj1 = 0 ;
27379 char * kwnames[] = {
27380 (char *) "self",(char *) "name", NULL
27381 };
27382
27383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27385 if (!SWIG_IsOK(res1)) {
27386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27387 }
27388 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27389 {
27390 arg2 = wxString_in_helper(obj1);
27391 if (arg2 == NULL) SWIG_fail;
27392 temp2 = true;
27393 }
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 (arg1)->SetClassName((wxString const &)*arg2);
27397 wxPyEndAllowThreads(__tstate);
27398 if (PyErr_Occurred()) SWIG_fail;
27399 }
27400 resultobj = SWIG_Py_Void();
27401 {
27402 if (temp2)
27403 delete arg2;
27404 }
27405 return resultobj;
27406 fail:
27407 {
27408 if (temp2)
27409 delete arg2;
27410 }
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27416 PyObject *resultobj = 0;
27417 wxPyApp *arg1 = (wxPyApp *) 0 ;
27418 wxString *result = 0 ;
27419 void *argp1 = 0 ;
27420 int res1 = 0 ;
27421 PyObject *swig_obj[1] ;
27422
27423 if (!args) SWIG_fail;
27424 swig_obj[0] = args;
27425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27426 if (!SWIG_IsOK(res1)) {
27427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27428 }
27429 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27430 {
27431 PyThreadState* __tstate = wxPyBeginAllowThreads();
27432 {
27433 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27434 result = (wxString *) &_result_ref;
27435 }
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 {
27440 #if wxUSE_UNICODE
27441 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27442 #else
27443 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27444 #endif
27445 }
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27453 PyObject *resultobj = 0;
27454 wxPyApp *arg1 = (wxPyApp *) 0 ;
27455 wxString *arg2 = 0 ;
27456 void *argp1 = 0 ;
27457 int res1 = 0 ;
27458 bool temp2 = false ;
27459 PyObject * obj0 = 0 ;
27460 PyObject * obj1 = 0 ;
27461 char * kwnames[] = {
27462 (char *) "self",(char *) "name", NULL
27463 };
27464
27465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27467 if (!SWIG_IsOK(res1)) {
27468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27469 }
27470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27471 {
27472 arg2 = wxString_in_helper(obj1);
27473 if (arg2 == NULL) SWIG_fail;
27474 temp2 = true;
27475 }
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 (arg1)->SetVendorName((wxString const &)*arg2);
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = SWIG_Py_Void();
27483 {
27484 if (temp2)
27485 delete arg2;
27486 }
27487 return resultobj;
27488 fail:
27489 {
27490 if (temp2)
27491 delete arg2;
27492 }
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 wxPyApp *arg1 = (wxPyApp *) 0 ;
27500 wxAppTraits *result = 0 ;
27501 void *argp1 = 0 ;
27502 int res1 = 0 ;
27503 PyObject *swig_obj[1] ;
27504
27505 if (!args) SWIG_fail;
27506 swig_obj[0] = args;
27507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27510 }
27511 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (wxAppTraits *)(arg1)->GetTraits();
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27519 return resultobj;
27520 fail:
27521 return NULL;
27522 }
27523
27524
27525 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27526 PyObject *resultobj = 0;
27527 wxPyApp *arg1 = (wxPyApp *) 0 ;
27528 void *argp1 = 0 ;
27529 int res1 = 0 ;
27530 PyObject *swig_obj[1] ;
27531
27532 if (!args) SWIG_fail;
27533 swig_obj[0] = args;
27534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27535 if (!SWIG_IsOK(res1)) {
27536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27537 }
27538 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27539 {
27540 PyThreadState* __tstate = wxPyBeginAllowThreads();
27541 (arg1)->ProcessPendingEvents();
27542 wxPyEndAllowThreads(__tstate);
27543 if (PyErr_Occurred()) SWIG_fail;
27544 }
27545 resultobj = SWIG_Py_Void();
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27553 PyObject *resultobj = 0;
27554 wxPyApp *arg1 = (wxPyApp *) 0 ;
27555 bool arg2 = (bool) false ;
27556 bool result;
27557 void *argp1 = 0 ;
27558 int res1 = 0 ;
27559 bool val2 ;
27560 int ecode2 = 0 ;
27561 PyObject * obj0 = 0 ;
27562 PyObject * obj1 = 0 ;
27563 char * kwnames[] = {
27564 (char *) "self",(char *) "onlyIfNeeded", NULL
27565 };
27566
27567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27569 if (!SWIG_IsOK(res1)) {
27570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27571 }
27572 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27573 if (obj1) {
27574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27575 if (!SWIG_IsOK(ecode2)) {
27576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27577 }
27578 arg2 = static_cast< bool >(val2);
27579 }
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (bool)(arg1)->Yield(arg2);
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxPyApp *arg1 = (wxPyApp *) 0 ;
27598 void *argp1 = 0 ;
27599 int res1 = 0 ;
27600 PyObject *swig_obj[1] ;
27601
27602 if (!args) SWIG_fail;
27603 swig_obj[0] = args;
27604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27605 if (!SWIG_IsOK(res1)) {
27606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27607 }
27608 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 (arg1)->WakeUpIdle();
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 resultobj = SWIG_Py_Void();
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27623 PyObject *resultobj = 0;
27624 bool result;
27625
27626 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 result = (bool)wxPyApp::IsMainLoopRunning();
27630 wxPyEndAllowThreads(__tstate);
27631 if (PyErr_Occurred()) SWIG_fail;
27632 }
27633 {
27634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27635 }
27636 return resultobj;
27637 fail:
27638 return NULL;
27639 }
27640
27641
27642 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27643 PyObject *resultobj = 0;
27644 wxPyApp *arg1 = (wxPyApp *) 0 ;
27645 int result;
27646 void *argp1 = 0 ;
27647 int res1 = 0 ;
27648 PyObject *swig_obj[1] ;
27649
27650 if (!args) SWIG_fail;
27651 swig_obj[0] = args;
27652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27653 if (!SWIG_IsOK(res1)) {
27654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27655 }
27656 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27657 {
27658 PyThreadState* __tstate = wxPyBeginAllowThreads();
27659 result = (int)(arg1)->MainLoop();
27660 wxPyEndAllowThreads(__tstate);
27661 if (PyErr_Occurred()) SWIG_fail;
27662 }
27663 resultobj = SWIG_From_int(static_cast< int >(result));
27664 return resultobj;
27665 fail:
27666 return NULL;
27667 }
27668
27669
27670 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27671 PyObject *resultobj = 0;
27672 wxPyApp *arg1 = (wxPyApp *) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 PyObject *swig_obj[1] ;
27676
27677 if (!args) SWIG_fail;
27678 swig_obj[0] = args;
27679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27680 if (!SWIG_IsOK(res1)) {
27681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27682 }
27683 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->Exit();
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = SWIG_Py_Void();
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27698 PyObject *resultobj = 0;
27699 wxPyApp *arg1 = (wxPyApp *) 0 ;
27700 void *argp1 = 0 ;
27701 int res1 = 0 ;
27702 PyObject *swig_obj[1] ;
27703
27704 if (!args) SWIG_fail;
27705 swig_obj[0] = args;
27706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27707 if (!SWIG_IsOK(res1)) {
27708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27709 }
27710 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->ExitMainLoop();
27714 wxPyEndAllowThreads(__tstate);
27715 if (PyErr_Occurred()) SWIG_fail;
27716 }
27717 resultobj = SWIG_Py_Void();
27718 return resultobj;
27719 fail:
27720 return NULL;
27721 }
27722
27723
27724 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27725 PyObject *resultobj = 0;
27726 wxPyApp *arg1 = (wxPyApp *) 0 ;
27727 bool result;
27728 void *argp1 = 0 ;
27729 int res1 = 0 ;
27730 PyObject *swig_obj[1] ;
27731
27732 if (!args) SWIG_fail;
27733 swig_obj[0] = args;
27734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27735 if (!SWIG_IsOK(res1)) {
27736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27737 }
27738 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27739 {
27740 PyThreadState* __tstate = wxPyBeginAllowThreads();
27741 result = (bool)(arg1)->Pending();
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 {
27746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27747 }
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27755 PyObject *resultobj = 0;
27756 wxPyApp *arg1 = (wxPyApp *) 0 ;
27757 bool result;
27758 void *argp1 = 0 ;
27759 int res1 = 0 ;
27760 PyObject *swig_obj[1] ;
27761
27762 if (!args) SWIG_fail;
27763 swig_obj[0] = args;
27764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27765 if (!SWIG_IsOK(res1)) {
27766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27767 }
27768 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27769 {
27770 PyThreadState* __tstate = wxPyBeginAllowThreads();
27771 result = (bool)(arg1)->Dispatch();
27772 wxPyEndAllowThreads(__tstate);
27773 if (PyErr_Occurred()) SWIG_fail;
27774 }
27775 {
27776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27777 }
27778 return resultobj;
27779 fail:
27780 return NULL;
27781 }
27782
27783
27784 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27785 PyObject *resultobj = 0;
27786 wxPyApp *arg1 = (wxPyApp *) 0 ;
27787 bool result;
27788 void *argp1 = 0 ;
27789 int res1 = 0 ;
27790 PyObject *swig_obj[1] ;
27791
27792 if (!args) SWIG_fail;
27793 swig_obj[0] = args;
27794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27795 if (!SWIG_IsOK(res1)) {
27796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27797 }
27798 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 result = (bool)(arg1)->ProcessIdle();
27802 wxPyEndAllowThreads(__tstate);
27803 if (PyErr_Occurred()) SWIG_fail;
27804 }
27805 {
27806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27807 }
27808 return resultobj;
27809 fail:
27810 return NULL;
27811 }
27812
27813
27814 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27815 PyObject *resultobj = 0;
27816 wxPyApp *arg1 = (wxPyApp *) 0 ;
27817 wxWindow *arg2 = (wxWindow *) 0 ;
27818 wxIdleEvent *arg3 = 0 ;
27819 bool result;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 void *argp2 = 0 ;
27823 int res2 = 0 ;
27824 void *argp3 = 0 ;
27825 int res3 = 0 ;
27826 PyObject * obj0 = 0 ;
27827 PyObject * obj1 = 0 ;
27828 PyObject * obj2 = 0 ;
27829 char * kwnames[] = {
27830 (char *) "self",(char *) "win",(char *) "event", NULL
27831 };
27832
27833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27835 if (!SWIG_IsOK(res1)) {
27836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27837 }
27838 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27840 if (!SWIG_IsOK(res2)) {
27841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27842 }
27843 arg2 = reinterpret_cast< wxWindow * >(argp2);
27844 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27845 if (!SWIG_IsOK(res3)) {
27846 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27847 }
27848 if (!argp3) {
27849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27850 }
27851 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxPyApp *arg1 = (wxPyApp *) 0 ;
27870 bool result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = (bool)((wxPyApp const *)arg1)->IsActive();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 {
27889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27890 }
27891 return resultobj;
27892 fail:
27893 return NULL;
27894 }
27895
27896
27897 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27898 PyObject *resultobj = 0;
27899 wxPyApp *arg1 = (wxPyApp *) 0 ;
27900 wxWindow *arg2 = (wxWindow *) 0 ;
27901 void *argp1 = 0 ;
27902 int res1 = 0 ;
27903 void *argp2 = 0 ;
27904 int res2 = 0 ;
27905 PyObject * obj0 = 0 ;
27906 PyObject * obj1 = 0 ;
27907 char * kwnames[] = {
27908 (char *) "self",(char *) "win", NULL
27909 };
27910
27911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27913 if (!SWIG_IsOK(res1)) {
27914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27915 }
27916 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27917 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27918 if (!SWIG_IsOK(res2)) {
27919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27920 }
27921 arg2 = reinterpret_cast< wxWindow * >(argp2);
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 (arg1)->SetTopWindow(arg2);
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 resultobj = SWIG_Py_Void();
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27936 PyObject *resultobj = 0;
27937 wxPyApp *arg1 = (wxPyApp *) 0 ;
27938 wxWindow *result = 0 ;
27939 void *argp1 = 0 ;
27940 int res1 = 0 ;
27941 PyObject *swig_obj[1] ;
27942
27943 if (!args) SWIG_fail;
27944 swig_obj[0] = args;
27945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27946 if (!SWIG_IsOK(res1)) {
27947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27948 }
27949 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 resultobj = wxPyMake_wxObject(result, (bool)0);
27958 }
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj = 0;
27967 wxPyApp *arg1 = (wxPyApp *) 0 ;
27968 bool arg2 ;
27969 void *argp1 = 0 ;
27970 int res1 = 0 ;
27971 bool val2 ;
27972 int ecode2 = 0 ;
27973 PyObject * obj0 = 0 ;
27974 PyObject * obj1 = 0 ;
27975 char * kwnames[] = {
27976 (char *) "self",(char *) "flag", NULL
27977 };
27978
27979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27981 if (!SWIG_IsOK(res1)) {
27982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27983 }
27984 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27985 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27986 if (!SWIG_IsOK(ecode2)) {
27987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27988 }
27989 arg2 = static_cast< bool >(val2);
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 (arg1)->SetExitOnFrameDelete(arg2);
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 resultobj = SWIG_Py_Void();
27997 return resultobj;
27998 fail:
27999 return NULL;
28000 }
28001
28002
28003 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28004 PyObject *resultobj = 0;
28005 wxPyApp *arg1 = (wxPyApp *) 0 ;
28006 bool result;
28007 void *argp1 = 0 ;
28008 int res1 = 0 ;
28009 PyObject *swig_obj[1] ;
28010
28011 if (!args) SWIG_fail;
28012 swig_obj[0] = args;
28013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28016 }
28017 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 {
28025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28026 }
28027 return resultobj;
28028 fail:
28029 return NULL;
28030 }
28031
28032
28033 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28034 PyObject *resultobj = 0;
28035 wxPyApp *arg1 = (wxPyApp *) 0 ;
28036 bool arg2 ;
28037 void *argp1 = 0 ;
28038 int res1 = 0 ;
28039 bool val2 ;
28040 int ecode2 = 0 ;
28041 PyObject * obj0 = 0 ;
28042 PyObject * obj1 = 0 ;
28043 char * kwnames[] = {
28044 (char *) "self",(char *) "flag", NULL
28045 };
28046
28047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28049 if (!SWIG_IsOK(res1)) {
28050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28051 }
28052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28053 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28054 if (!SWIG_IsOK(ecode2)) {
28055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28056 }
28057 arg2 = static_cast< bool >(val2);
28058 {
28059 PyThreadState* __tstate = wxPyBeginAllowThreads();
28060 (arg1)->SetUseBestVisual(arg2);
28061 wxPyEndAllowThreads(__tstate);
28062 if (PyErr_Occurred()) SWIG_fail;
28063 }
28064 resultobj = SWIG_Py_Void();
28065 return resultobj;
28066 fail:
28067 return NULL;
28068 }
28069
28070
28071 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28072 PyObject *resultobj = 0;
28073 wxPyApp *arg1 = (wxPyApp *) 0 ;
28074 bool result;
28075 void *argp1 = 0 ;
28076 int res1 = 0 ;
28077 PyObject *swig_obj[1] ;
28078
28079 if (!args) SWIG_fail;
28080 swig_obj[0] = args;
28081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28082 if (!SWIG_IsOK(res1)) {
28083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28084 }
28085 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28086 {
28087 PyThreadState* __tstate = wxPyBeginAllowThreads();
28088 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28089 wxPyEndAllowThreads(__tstate);
28090 if (PyErr_Occurred()) SWIG_fail;
28091 }
28092 {
28093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28094 }
28095 return resultobj;
28096 fail:
28097 return NULL;
28098 }
28099
28100
28101 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28102 PyObject *resultobj = 0;
28103 wxPyApp *arg1 = (wxPyApp *) 0 ;
28104 int arg2 ;
28105 void *argp1 = 0 ;
28106 int res1 = 0 ;
28107 int val2 ;
28108 int ecode2 = 0 ;
28109 PyObject * obj0 = 0 ;
28110 PyObject * obj1 = 0 ;
28111 char * kwnames[] = {
28112 (char *) "self",(char *) "mode", NULL
28113 };
28114
28115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28119 }
28120 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28121 ecode2 = SWIG_AsVal_int(obj1, &val2);
28122 if (!SWIG_IsOK(ecode2)) {
28123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28124 }
28125 arg2 = static_cast< int >(val2);
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 (arg1)->SetPrintMode(arg2);
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 resultobj = SWIG_Py_Void();
28133 return resultobj;
28134 fail:
28135 return NULL;
28136 }
28137
28138
28139 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28140 PyObject *resultobj = 0;
28141 wxPyApp *arg1 = (wxPyApp *) 0 ;
28142 int result;
28143 void *argp1 = 0 ;
28144 int res1 = 0 ;
28145 PyObject *swig_obj[1] ;
28146
28147 if (!args) SWIG_fail;
28148 swig_obj[0] = args;
28149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28152 }
28153 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28157 wxPyEndAllowThreads(__tstate);
28158 if (PyErr_Occurred()) SWIG_fail;
28159 }
28160 resultobj = SWIG_From_int(static_cast< int >(result));
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28168 PyObject *resultobj = 0;
28169 wxPyApp *arg1 = (wxPyApp *) 0 ;
28170 int arg2 ;
28171 void *argp1 = 0 ;
28172 int res1 = 0 ;
28173 int val2 ;
28174 int ecode2 = 0 ;
28175 PyObject * obj0 = 0 ;
28176 PyObject * obj1 = 0 ;
28177 char * kwnames[] = {
28178 (char *) "self",(char *) "mode", NULL
28179 };
28180
28181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28183 if (!SWIG_IsOK(res1)) {
28184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28185 }
28186 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28187 ecode2 = SWIG_AsVal_int(obj1, &val2);
28188 if (!SWIG_IsOK(ecode2)) {
28189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28190 }
28191 arg2 = static_cast< int >(val2);
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 (arg1)->SetAssertMode(arg2);
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_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28206 PyObject *resultobj = 0;
28207 wxPyApp *arg1 = (wxPyApp *) 0 ;
28208 int result;
28209 void *argp1 = 0 ;
28210 int res1 = 0 ;
28211 PyObject *swig_obj[1] ;
28212
28213 if (!args) SWIG_fail;
28214 swig_obj[0] = args;
28215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28216 if (!SWIG_IsOK(res1)) {
28217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28218 }
28219 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28220 {
28221 PyThreadState* __tstate = wxPyBeginAllowThreads();
28222 result = (int)(arg1)->GetAssertMode();
28223 wxPyEndAllowThreads(__tstate);
28224 if (PyErr_Occurred()) SWIG_fail;
28225 }
28226 resultobj = SWIG_From_int(static_cast< int >(result));
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28234 PyObject *resultobj = 0;
28235 bool result;
28236
28237 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28241 wxPyEndAllowThreads(__tstate);
28242 if (PyErr_Occurred()) SWIG_fail;
28243 }
28244 {
28245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28246 }
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 PyObject *resultobj = 0;
28255 long result;
28256
28257 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = (long)wxPyApp::GetMacAboutMenuItemId();
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 resultobj = SWIG_From_long(static_cast< long >(result));
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28272 PyObject *resultobj = 0;
28273 long result;
28274
28275 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_From_long(static_cast< long >(result));
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28290 PyObject *resultobj = 0;
28291 long result;
28292
28293 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (long)wxPyApp::GetMacExitMenuItemId();
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_From_long(static_cast< long >(result));
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxString result;
28310
28311 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = wxPyApp::GetMacHelpMenuTitleName();
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 {
28319 #if wxUSE_UNICODE
28320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28321 #else
28322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28323 #endif
28324 }
28325 return resultobj;
28326 fail:
28327 return NULL;
28328 }
28329
28330
28331 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28332 PyObject *resultobj = 0;
28333 bool arg1 ;
28334 bool val1 ;
28335 int ecode1 = 0 ;
28336 PyObject * obj0 = 0 ;
28337 char * kwnames[] = {
28338 (char *) "val", NULL
28339 };
28340
28341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28342 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28343 if (!SWIG_IsOK(ecode1)) {
28344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28345 }
28346 arg1 = static_cast< bool >(val1);
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28350 wxPyEndAllowThreads(__tstate);
28351 if (PyErr_Occurred()) SWIG_fail;
28352 }
28353 resultobj = SWIG_Py_Void();
28354 return resultobj;
28355 fail:
28356 return NULL;
28357 }
28358
28359
28360 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28361 PyObject *resultobj = 0;
28362 long arg1 ;
28363 long val1 ;
28364 int ecode1 = 0 ;
28365 PyObject * obj0 = 0 ;
28366 char * kwnames[] = {
28367 (char *) "val", NULL
28368 };
28369
28370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28371 ecode1 = SWIG_AsVal_long(obj0, &val1);
28372 if (!SWIG_IsOK(ecode1)) {
28373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28374 }
28375 arg1 = static_cast< long >(val1);
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 wxPyApp::SetMacAboutMenuItemId(arg1);
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 resultobj = SWIG_Py_Void();
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28390 PyObject *resultobj = 0;
28391 long arg1 ;
28392 long val1 ;
28393 int ecode1 = 0 ;
28394 PyObject * obj0 = 0 ;
28395 char * kwnames[] = {
28396 (char *) "val", NULL
28397 };
28398
28399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28400 ecode1 = SWIG_AsVal_long(obj0, &val1);
28401 if (!SWIG_IsOK(ecode1)) {
28402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28403 }
28404 arg1 = static_cast< long >(val1);
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 resultobj = SWIG_Py_Void();
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj = 0;
28420 long arg1 ;
28421 long val1 ;
28422 int ecode1 = 0 ;
28423 PyObject * obj0 = 0 ;
28424 char * kwnames[] = {
28425 (char *) "val", NULL
28426 };
28427
28428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28429 ecode1 = SWIG_AsVal_long(obj0, &val1);
28430 if (!SWIG_IsOK(ecode1)) {
28431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28432 }
28433 arg1 = static_cast< long >(val1);
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 wxPyApp::SetMacExitMenuItemId(arg1);
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 resultobj = SWIG_Py_Void();
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj = 0;
28449 wxString *arg1 = 0 ;
28450 bool temp1 = false ;
28451 PyObject * obj0 = 0 ;
28452 char * kwnames[] = {
28453 (char *) "val", NULL
28454 };
28455
28456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28457 {
28458 arg1 = wxString_in_helper(obj0);
28459 if (arg1 == NULL) SWIG_fail;
28460 temp1 = true;
28461 }
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 resultobj = SWIG_Py_Void();
28469 {
28470 if (temp1)
28471 delete arg1;
28472 }
28473 return resultobj;
28474 fail:
28475 {
28476 if (temp1)
28477 delete arg1;
28478 }
28479 return NULL;
28480 }
28481
28482
28483 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28484 PyObject *resultobj = 0;
28485 wxPyApp *arg1 = (wxPyApp *) 0 ;
28486 void *argp1 = 0 ;
28487 int res1 = 0 ;
28488 PyObject *swig_obj[1] ;
28489
28490 if (!args) SWIG_fail;
28491 swig_obj[0] = args;
28492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28495 }
28496 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->_BootstrapApp();
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 resultobj = SWIG_Py_Void();
28504 return resultobj;
28505 fail:
28506 return NULL;
28507 }
28508
28509
28510 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28511 PyObject *resultobj = 0;
28512 int result;
28513
28514 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 result = (int)wxPyApp_GetComCtl32Version();
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 resultobj = SWIG_From_int(static_cast< int >(result));
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 bool result;
28531
28532 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (bool)wxPyApp_DisplayAvailable();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 {
28540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28541 }
28542 return resultobj;
28543 fail:
28544 return NULL;
28545 }
28546
28547
28548 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28549 PyObject *obj;
28550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28551 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28552 return SWIG_Py_Void();
28553 }
28554
28555 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28556 return SWIG_Python_InitShadowInstance(args);
28557 }
28558
28559 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28560 PyObject *resultobj = 0;
28561
28562 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 wxExit();
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 resultobj = SWIG_Py_Void();
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28577 PyObject *resultobj = 0;
28578 bool result;
28579
28580 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28581 {
28582 PyThreadState* __tstate = wxPyBeginAllowThreads();
28583 result = (bool)wxYield();
28584 wxPyEndAllowThreads(__tstate);
28585 if (PyErr_Occurred()) SWIG_fail;
28586 }
28587 {
28588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28589 }
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28597 PyObject *resultobj = 0;
28598 bool result;
28599
28600 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (bool)wxYieldIfNeeded();
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 {
28608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28609 }
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28617 PyObject *resultobj = 0;
28618 wxWindow *arg1 = (wxWindow *) NULL ;
28619 bool arg2 = (bool) false ;
28620 bool result;
28621 void *argp1 = 0 ;
28622 int res1 = 0 ;
28623 bool val2 ;
28624 int ecode2 = 0 ;
28625 PyObject * obj0 = 0 ;
28626 PyObject * obj1 = 0 ;
28627 char * kwnames[] = {
28628 (char *) "win",(char *) "onlyIfNeeded", NULL
28629 };
28630
28631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28632 if (obj0) {
28633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28634 if (!SWIG_IsOK(res1)) {
28635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28636 }
28637 arg1 = reinterpret_cast< wxWindow * >(argp1);
28638 }
28639 if (obj1) {
28640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28641 if (!SWIG_IsOK(ecode2)) {
28642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28643 }
28644 arg2 = static_cast< bool >(val2);
28645 }
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = (bool)wxSafeYield(arg1,arg2);
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 {
28653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28654 }
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28662 PyObject *resultobj = 0;
28663
28664 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 wxWakeUpIdle();
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 resultobj = SWIG_Py_Void();
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = 0;
28680 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28681 wxEvent *arg2 = 0 ;
28682 void *argp1 = 0 ;
28683 int res1 = 0 ;
28684 void *argp2 = 0 ;
28685 int res2 = 0 ;
28686 PyObject * obj0 = 0 ;
28687 PyObject * obj1 = 0 ;
28688 char * kwnames[] = {
28689 (char *) "dest",(char *) "event", NULL
28690 };
28691
28692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28694 if (!SWIG_IsOK(res1)) {
28695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28696 }
28697 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28698 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28699 if (!SWIG_IsOK(res2)) {
28700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28701 }
28702 if (!argp2) {
28703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28704 }
28705 arg2 = reinterpret_cast< wxEvent * >(argp2);
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 wxPostEvent(arg1,*arg2);
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_Py_Void();
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28720 PyObject *resultobj = 0;
28721
28722 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 wxApp_CleanUp();
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_Py_Void();
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *resultobj = 0;
28738 wxPyApp *result = 0 ;
28739
28740 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = (wxPyApp *)wxPyGetApp();
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 {
28748 resultobj = wxPyMake_wxObject(result, 0);
28749 }
28750 return resultobj;
28751 fail:
28752 return NULL;
28753 }
28754
28755
28756 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28757 PyObject *resultobj = 0;
28758 char *arg1 = (char *) 0 ;
28759 int res1 ;
28760 char *buf1 = 0 ;
28761 int alloc1 = 0 ;
28762 PyObject * obj0 = 0 ;
28763 char * kwnames[] = {
28764 (char *) "encoding", NULL
28765 };
28766
28767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28768 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28769 if (!SWIG_IsOK(res1)) {
28770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28771 }
28772 arg1 = buf1;
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 wxSetDefaultPyEncoding((char const *)arg1);
28776 wxPyEndAllowThreads(__tstate);
28777 if (PyErr_Occurred()) SWIG_fail;
28778 }
28779 resultobj = SWIG_Py_Void();
28780 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28781 return resultobj;
28782 fail:
28783 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28789 PyObject *resultobj = 0;
28790 char *result = 0 ;
28791
28792 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = (char *)wxGetDefaultPyEncoding();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_FromCharPtr(result);
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808 wxEventLoop *result = 0 ;
28809
28810 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (wxEventLoop *)new wxEventLoop();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28827 void *argp1 = 0 ;
28828 int res1 = 0 ;
28829 PyObject *swig_obj[1] ;
28830
28831 if (!args) SWIG_fail;
28832 swig_obj[0] = args;
28833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28834 if (!SWIG_IsOK(res1)) {
28835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28836 }
28837 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 delete arg1;
28841
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 resultobj = SWIG_Py_Void();
28846 return resultobj;
28847 fail:
28848 return NULL;
28849 }
28850
28851
28852 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28853 PyObject *resultobj = 0;
28854 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28855 int result;
28856 void *argp1 = 0 ;
28857 int res1 = 0 ;
28858 PyObject *swig_obj[1] ;
28859
28860 if (!args) SWIG_fail;
28861 swig_obj[0] = args;
28862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28863 if (!SWIG_IsOK(res1)) {
28864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28865 }
28866 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28867 {
28868 PyThreadState* __tstate = wxPyBeginAllowThreads();
28869 result = (int)(arg1)->Run();
28870 wxPyEndAllowThreads(__tstate);
28871 if (PyErr_Occurred()) SWIG_fail;
28872 }
28873 resultobj = SWIG_From_int(static_cast< int >(result));
28874 return resultobj;
28875 fail:
28876 return NULL;
28877 }
28878
28879
28880 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28881 PyObject *resultobj = 0;
28882 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28883 int arg2 = (int) 0 ;
28884 void *argp1 = 0 ;
28885 int res1 = 0 ;
28886 int val2 ;
28887 int ecode2 = 0 ;
28888 PyObject * obj0 = 0 ;
28889 PyObject * obj1 = 0 ;
28890 char * kwnames[] = {
28891 (char *) "self",(char *) "rc", NULL
28892 };
28893
28894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28896 if (!SWIG_IsOK(res1)) {
28897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28898 }
28899 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28900 if (obj1) {
28901 ecode2 = SWIG_AsVal_int(obj1, &val2);
28902 if (!SWIG_IsOK(ecode2)) {
28903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28904 }
28905 arg2 = static_cast< int >(val2);
28906 }
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 (arg1)->Exit(arg2);
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 resultobj = SWIG_Py_Void();
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28921 PyObject *resultobj = 0;
28922 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28923 bool result;
28924 void *argp1 = 0 ;
28925 int res1 = 0 ;
28926 PyObject *swig_obj[1] ;
28927
28928 if (!args) SWIG_fail;
28929 swig_obj[0] = args;
28930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28931 if (!SWIG_IsOK(res1)) {
28932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28933 }
28934 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 result = (bool)((wxEventLoop const *)arg1)->Pending();
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 {
28942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28943 }
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28951 PyObject *resultobj = 0;
28952 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28953 bool result;
28954 void *argp1 = 0 ;
28955 int res1 = 0 ;
28956 PyObject *swig_obj[1] ;
28957
28958 if (!args) SWIG_fail;
28959 swig_obj[0] = args;
28960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28961 if (!SWIG_IsOK(res1)) {
28962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28963 }
28964 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 result = (bool)(arg1)->Dispatch();
28968 wxPyEndAllowThreads(__tstate);
28969 if (PyErr_Occurred()) SWIG_fail;
28970 }
28971 {
28972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28973 }
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 PyObject *resultobj = 0;
28982 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28983 bool result;
28984 void *argp1 = 0 ;
28985 int res1 = 0 ;
28986 PyObject *swig_obj[1] ;
28987
28988 if (!args) SWIG_fail;
28989 swig_obj[0] = args;
28990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28991 if (!SWIG_IsOK(res1)) {
28992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28993 }
28994 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28995 {
28996 PyThreadState* __tstate = wxPyBeginAllowThreads();
28997 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 {
29002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29003 }
29004 return resultobj;
29005 fail:
29006 return NULL;
29007 }
29008
29009
29010 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29011 PyObject *resultobj = 0;
29012 wxEventLoop *result = 0 ;
29013
29014 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29015 {
29016 PyThreadState* __tstate = wxPyBeginAllowThreads();
29017 result = (wxEventLoop *)wxEventLoop::GetActive();
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29029 PyObject *resultobj = 0;
29030 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29031 void *argp1 = 0 ;
29032 int res1 = 0 ;
29033 PyObject * obj0 = 0 ;
29034 char * kwnames[] = {
29035 (char *) "loop", NULL
29036 };
29037
29038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29040 if (!SWIG_IsOK(res1)) {
29041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29042 }
29043 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 wxEventLoop::SetActive(arg1);
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 resultobj = SWIG_Py_Void();
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29058 PyObject *obj;
29059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29060 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29061 return SWIG_Py_Void();
29062 }
29063
29064 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29065 return SWIG_Python_InitShadowInstance(args);
29066 }
29067
29068 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29069 PyObject *resultobj = 0;
29070 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29071 wxEventLoopActivator *result = 0 ;
29072 void *argp1 = 0 ;
29073 int res1 = 0 ;
29074 PyObject * obj0 = 0 ;
29075 char * kwnames[] = {
29076 (char *) "evtLoop", NULL
29077 };
29078
29079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29083 }
29084 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 PyObject *resultobj = 0;
29100 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29101 void *argp1 = 0 ;
29102 int res1 = 0 ;
29103 PyObject *swig_obj[1] ;
29104
29105 if (!args) SWIG_fail;
29106 swig_obj[0] = args;
29107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29108 if (!SWIG_IsOK(res1)) {
29109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29110 }
29111 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 delete arg1;
29115
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_Py_Void();
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *EventLoopActivator_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_wxEventLoopActivator, SWIG_NewClientData(obj));
29130 return SWIG_Py_Void();
29131 }
29132
29133 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 return SWIG_Python_InitShadowInstance(args);
29135 }
29136
29137 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 int arg1 = (int) 0 ;
29140 int arg2 = (int) 0 ;
29141 int arg3 = (int) 0 ;
29142 wxAcceleratorEntry *result = 0 ;
29143 int val1 ;
29144 int ecode1 = 0 ;
29145 int val2 ;
29146 int ecode2 = 0 ;
29147 int val3 ;
29148 int ecode3 = 0 ;
29149 PyObject * obj0 = 0 ;
29150 PyObject * obj1 = 0 ;
29151 PyObject * obj2 = 0 ;
29152 char * kwnames[] = {
29153 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29154 };
29155
29156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29157 if (obj0) {
29158 ecode1 = SWIG_AsVal_int(obj0, &val1);
29159 if (!SWIG_IsOK(ecode1)) {
29160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29161 }
29162 arg1 = static_cast< int >(val1);
29163 }
29164 if (obj1) {
29165 ecode2 = SWIG_AsVal_int(obj1, &val2);
29166 if (!SWIG_IsOK(ecode2)) {
29167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29168 }
29169 arg2 = static_cast< int >(val2);
29170 }
29171 if (obj2) {
29172 ecode3 = SWIG_AsVal_int(obj2, &val3);
29173 if (!SWIG_IsOK(ecode3)) {
29174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29175 }
29176 arg3 = static_cast< int >(val3);
29177 }
29178 {
29179 PyThreadState* __tstate = wxPyBeginAllowThreads();
29180 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29185 return resultobj;
29186 fail:
29187 return NULL;
29188 }
29189
29190
29191 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29192 PyObject *resultobj = 0;
29193 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 PyObject *swig_obj[1] ;
29197
29198 if (!args) SWIG_fail;
29199 swig_obj[0] = args;
29200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29201 if (!SWIG_IsOK(res1)) {
29202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29203 }
29204 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 delete arg1;
29208
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 resultobj = SWIG_Py_Void();
29213 return resultobj;
29214 fail:
29215 return NULL;
29216 }
29217
29218
29219 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29220 PyObject *resultobj = 0;
29221 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29222 int arg2 ;
29223 int arg3 ;
29224 int arg4 ;
29225 void *argp1 = 0 ;
29226 int res1 = 0 ;
29227 int val2 ;
29228 int ecode2 = 0 ;
29229 int val3 ;
29230 int ecode3 = 0 ;
29231 int val4 ;
29232 int ecode4 = 0 ;
29233 PyObject * obj0 = 0 ;
29234 PyObject * obj1 = 0 ;
29235 PyObject * obj2 = 0 ;
29236 PyObject * obj3 = 0 ;
29237 char * kwnames[] = {
29238 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29239 };
29240
29241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29243 if (!SWIG_IsOK(res1)) {
29244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29245 }
29246 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29247 ecode2 = SWIG_AsVal_int(obj1, &val2);
29248 if (!SWIG_IsOK(ecode2)) {
29249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29250 }
29251 arg2 = static_cast< int >(val2);
29252 ecode3 = SWIG_AsVal_int(obj2, &val3);
29253 if (!SWIG_IsOK(ecode3)) {
29254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29255 }
29256 arg3 = static_cast< int >(val3);
29257 ecode4 = SWIG_AsVal_int(obj3, &val4);
29258 if (!SWIG_IsOK(ecode4)) {
29259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29260 }
29261 arg4 = static_cast< int >(val4);
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 (arg1)->Set(arg2,arg3,arg4);
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_Py_Void();
29269 return resultobj;
29270 fail:
29271 return NULL;
29272 }
29273
29274
29275 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29276 PyObject *resultobj = 0;
29277 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29278 int result;
29279 void *argp1 = 0 ;
29280 int res1 = 0 ;
29281 PyObject *swig_obj[1] ;
29282
29283 if (!args) SWIG_fail;
29284 swig_obj[0] = args;
29285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29286 if (!SWIG_IsOK(res1)) {
29287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29288 }
29289 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29290 {
29291 PyThreadState* __tstate = wxPyBeginAllowThreads();
29292 result = (int)(arg1)->GetFlags();
29293 wxPyEndAllowThreads(__tstate);
29294 if (PyErr_Occurred()) SWIG_fail;
29295 }
29296 resultobj = SWIG_From_int(static_cast< int >(result));
29297 return resultobj;
29298 fail:
29299 return NULL;
29300 }
29301
29302
29303 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29304 PyObject *resultobj = 0;
29305 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29306 int result;
29307 void *argp1 = 0 ;
29308 int res1 = 0 ;
29309 PyObject *swig_obj[1] ;
29310
29311 if (!args) SWIG_fail;
29312 swig_obj[0] = args;
29313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29314 if (!SWIG_IsOK(res1)) {
29315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29316 }
29317 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29318 {
29319 PyThreadState* __tstate = wxPyBeginAllowThreads();
29320 result = (int)(arg1)->GetKeyCode();
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 resultobj = SWIG_From_int(static_cast< int >(result));
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29332 PyObject *resultobj = 0;
29333 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29334 int result;
29335 void *argp1 = 0 ;
29336 int res1 = 0 ;
29337 PyObject *swig_obj[1] ;
29338
29339 if (!args) SWIG_fail;
29340 swig_obj[0] = args;
29341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29342 if (!SWIG_IsOK(res1)) {
29343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29344 }
29345 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = (int)(arg1)->GetCommand();
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_From_int(static_cast< int >(result));
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29360 PyObject *obj;
29361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29362 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29363 return SWIG_Py_Void();
29364 }
29365
29366 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29367 return SWIG_Python_InitShadowInstance(args);
29368 }
29369
29370 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29371 PyObject *resultobj = 0;
29372 int arg1 ;
29373 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29374 wxAcceleratorTable *result = 0 ;
29375 PyObject * obj0 = 0 ;
29376 char * kwnames[] = {
29377 (char *) "n", NULL
29378 };
29379
29380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29381 {
29382 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29383 if (arg2) arg1 = PyList_Size(obj0);
29384 else arg1 = 0;
29385 }
29386 {
29387 PyThreadState* __tstate = wxPyBeginAllowThreads();
29388 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 PyObject *resultobj = 0;
29401 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29402 void *argp1 = 0 ;
29403 int res1 = 0 ;
29404 PyObject *swig_obj[1] ;
29405
29406 if (!args) SWIG_fail;
29407 swig_obj[0] = args;
29408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29409 if (!SWIG_IsOK(res1)) {
29410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29411 }
29412 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29413 {
29414 PyThreadState* __tstate = wxPyBeginAllowThreads();
29415 delete arg1;
29416
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 resultobj = SWIG_Py_Void();
29421 return resultobj;
29422 fail:
29423 return NULL;
29424 }
29425
29426
29427 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29428 PyObject *resultobj = 0;
29429 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29430 bool result;
29431 void *argp1 = 0 ;
29432 int res1 = 0 ;
29433 PyObject *swig_obj[1] ;
29434
29435 if (!args) SWIG_fail;
29436 swig_obj[0] = args;
29437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29438 if (!SWIG_IsOK(res1)) {
29439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29440 }
29441 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29442 {
29443 PyThreadState* __tstate = wxPyBeginAllowThreads();
29444 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29445 wxPyEndAllowThreads(__tstate);
29446 if (PyErr_Occurred()) SWIG_fail;
29447 }
29448 {
29449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29450 }
29451 return resultobj;
29452 fail:
29453 return NULL;
29454 }
29455
29456
29457 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29458 PyObject *obj;
29459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29460 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29461 return SWIG_Py_Void();
29462 }
29463
29464 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29465 return SWIG_Python_InitShadowInstance(args);
29466 }
29467
29468 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29469 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29470 return 1;
29471 }
29472
29473
29474 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29475 PyObject *pyobj = 0;
29476
29477 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29478 return pyobj;
29479 }
29480
29481
29482 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29483 PyObject *resultobj = 0;
29484 wxString *arg1 = 0 ;
29485 wxAcceleratorEntry *result = 0 ;
29486 bool temp1 = false ;
29487 PyObject * obj0 = 0 ;
29488 char * kwnames[] = {
29489 (char *) "label", NULL
29490 };
29491
29492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29493 {
29494 arg1 = wxString_in_helper(obj0);
29495 if (arg1 == NULL) SWIG_fail;
29496 temp1 = true;
29497 }
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29501 wxPyEndAllowThreads(__tstate);
29502 if (PyErr_Occurred()) SWIG_fail;
29503 }
29504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29505 {
29506 if (temp1)
29507 delete arg1;
29508 }
29509 return resultobj;
29510 fail:
29511 {
29512 if (temp1)
29513 delete arg1;
29514 }
29515 return NULL;
29516 }
29517
29518
29519 SWIGINTERN int PanelNameStr_set(PyObject *) {
29520 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29521 return 1;
29522 }
29523
29524
29525 SWIGINTERN PyObject *PanelNameStr_get(void) {
29526 PyObject *pyobj = 0;
29527
29528 {
29529 #if wxUSE_UNICODE
29530 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29531 #else
29532 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29533 #endif
29534 }
29535 return pyobj;
29536 }
29537
29538
29539 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29540 PyObject *resultobj = 0;
29541 wxVisualAttributes *result = 0 ;
29542
29543 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = (wxVisualAttributes *)new_wxVisualAttributes();
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29551 return resultobj;
29552 fail:
29553 return NULL;
29554 }
29555
29556
29557 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29558 PyObject *resultobj = 0;
29559 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29560 void *argp1 = 0 ;
29561 int res1 = 0 ;
29562 PyObject *swig_obj[1] ;
29563
29564 if (!args) SWIG_fail;
29565 swig_obj[0] = args;
29566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29567 if (!SWIG_IsOK(res1)) {
29568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29569 }
29570 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 delete_wxVisualAttributes(arg1);
29574
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 resultobj = SWIG_Py_Void();
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29586 PyObject *resultobj = 0;
29587 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29588 wxFont *arg2 = (wxFont *) 0 ;
29589 void *argp1 = 0 ;
29590 int res1 = 0 ;
29591 void *argp2 = 0 ;
29592 int res2 = 0 ;
29593 PyObject *swig_obj[2] ;
29594
29595 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29597 if (!SWIG_IsOK(res1)) {
29598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29599 }
29600 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29601 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29602 if (!SWIG_IsOK(res2)) {
29603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29604 }
29605 arg2 = reinterpret_cast< wxFont * >(argp2);
29606 if (arg1) (arg1)->font = *arg2;
29607
29608 resultobj = SWIG_Py_Void();
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29616 PyObject *resultobj = 0;
29617 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29618 wxFont *result = 0 ;
29619 void *argp1 = 0 ;
29620 int res1 = 0 ;
29621 PyObject *swig_obj[1] ;
29622
29623 if (!args) SWIG_fail;
29624 swig_obj[0] = args;
29625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29626 if (!SWIG_IsOK(res1)) {
29627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29628 }
29629 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29630 result = (wxFont *)& ((arg1)->font);
29631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29632 return resultobj;
29633 fail:
29634 return NULL;
29635 }
29636
29637
29638 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29639 PyObject *resultobj = 0;
29640 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29641 wxColour *arg2 = (wxColour *) 0 ;
29642 void *argp1 = 0 ;
29643 int res1 = 0 ;
29644 void *argp2 = 0 ;
29645 int res2 = 0 ;
29646 PyObject *swig_obj[2] ;
29647
29648 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29650 if (!SWIG_IsOK(res1)) {
29651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29652 }
29653 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29654 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29655 if (!SWIG_IsOK(res2)) {
29656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29657 }
29658 arg2 = reinterpret_cast< wxColour * >(argp2);
29659 if (arg1) (arg1)->colFg = *arg2;
29660
29661 resultobj = SWIG_Py_Void();
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29669 PyObject *resultobj = 0;
29670 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29671 wxColour *result = 0 ;
29672 void *argp1 = 0 ;
29673 int res1 = 0 ;
29674 PyObject *swig_obj[1] ;
29675
29676 if (!args) SWIG_fail;
29677 swig_obj[0] = args;
29678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29679 if (!SWIG_IsOK(res1)) {
29680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29681 }
29682 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29683 result = (wxColour *)& ((arg1)->colFg);
29684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29692 PyObject *resultobj = 0;
29693 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29694 wxColour *arg2 = (wxColour *) 0 ;
29695 void *argp1 = 0 ;
29696 int res1 = 0 ;
29697 void *argp2 = 0 ;
29698 int res2 = 0 ;
29699 PyObject *swig_obj[2] ;
29700
29701 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29703 if (!SWIG_IsOK(res1)) {
29704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29705 }
29706 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29707 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29708 if (!SWIG_IsOK(res2)) {
29709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29710 }
29711 arg2 = reinterpret_cast< wxColour * >(argp2);
29712 if (arg1) (arg1)->colBg = *arg2;
29713
29714 resultobj = SWIG_Py_Void();
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29722 PyObject *resultobj = 0;
29723 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29724 wxColour *result = 0 ;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 PyObject *swig_obj[1] ;
29728
29729 if (!args) SWIG_fail;
29730 swig_obj[0] = args;
29731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29732 if (!SWIG_IsOK(res1)) {
29733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29734 }
29735 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29736 result = (wxColour *)& ((arg1)->colBg);
29737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29745 PyObject *obj;
29746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29747 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29748 return SWIG_Py_Void();
29749 }
29750
29751 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29752 return SWIG_Python_InitShadowInstance(args);
29753 }
29754
29755 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj = 0;
29757 wxWindow *arg1 = (wxWindow *) 0 ;
29758 int arg2 = (int) (int)-1 ;
29759 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29760 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29761 wxSize const &arg4_defvalue = wxDefaultSize ;
29762 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29763 long arg5 = (long) 0 ;
29764 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29765 wxString *arg6 = (wxString *) &arg6_defvalue ;
29766 wxWindow *result = 0 ;
29767 void *argp1 = 0 ;
29768 int res1 = 0 ;
29769 int val2 ;
29770 int ecode2 = 0 ;
29771 wxPoint temp3 ;
29772 wxSize temp4 ;
29773 long val5 ;
29774 int ecode5 = 0 ;
29775 bool temp6 = false ;
29776 PyObject * obj0 = 0 ;
29777 PyObject * obj1 = 0 ;
29778 PyObject * obj2 = 0 ;
29779 PyObject * obj3 = 0 ;
29780 PyObject * obj4 = 0 ;
29781 PyObject * obj5 = 0 ;
29782 char * kwnames[] = {
29783 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29784 };
29785
29786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29788 if (!SWIG_IsOK(res1)) {
29789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29790 }
29791 arg1 = reinterpret_cast< wxWindow * >(argp1);
29792 if (obj1) {
29793 ecode2 = SWIG_AsVal_int(obj1, &val2);
29794 if (!SWIG_IsOK(ecode2)) {
29795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29796 }
29797 arg2 = static_cast< int >(val2);
29798 }
29799 if (obj2) {
29800 {
29801 arg3 = &temp3;
29802 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29803 }
29804 }
29805 if (obj3) {
29806 {
29807 arg4 = &temp4;
29808 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29809 }
29810 }
29811 if (obj4) {
29812 ecode5 = SWIG_AsVal_long(obj4, &val5);
29813 if (!SWIG_IsOK(ecode5)) {
29814 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29815 }
29816 arg5 = static_cast< long >(val5);
29817 }
29818 if (obj5) {
29819 {
29820 arg6 = wxString_in_helper(obj5);
29821 if (arg6 == NULL) SWIG_fail;
29822 temp6 = true;
29823 }
29824 }
29825 {
29826 if (!wxPyCheckForApp()) SWIG_fail;
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29833 {
29834 if (temp6)
29835 delete arg6;
29836 }
29837 return resultobj;
29838 fail:
29839 {
29840 if (temp6)
29841 delete arg6;
29842 }
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848 PyObject *resultobj = 0;
29849 wxWindow *result = 0 ;
29850
29851 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29852 {
29853 if (!wxPyCheckForApp()) SWIG_fail;
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 result = (wxWindow *)new wxWindow();
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj = 0;
29868 wxWindow *arg1 = (wxWindow *) 0 ;
29869 wxWindow *arg2 = (wxWindow *) 0 ;
29870 int arg3 = (int) (int)-1 ;
29871 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29872 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29873 wxSize const &arg5_defvalue = wxDefaultSize ;
29874 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29875 long arg6 = (long) 0 ;
29876 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29877 wxString *arg7 = (wxString *) &arg7_defvalue ;
29878 bool result;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 int val3 ;
29884 int ecode3 = 0 ;
29885 wxPoint temp4 ;
29886 wxSize temp5 ;
29887 long val6 ;
29888 int ecode6 = 0 ;
29889 bool temp7 = false ;
29890 PyObject * obj0 = 0 ;
29891 PyObject * obj1 = 0 ;
29892 PyObject * obj2 = 0 ;
29893 PyObject * obj3 = 0 ;
29894 PyObject * obj4 = 0 ;
29895 PyObject * obj5 = 0 ;
29896 PyObject * obj6 = 0 ;
29897 char * kwnames[] = {
29898 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29899 };
29900
29901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29903 if (!SWIG_IsOK(res1)) {
29904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29905 }
29906 arg1 = reinterpret_cast< wxWindow * >(argp1);
29907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29908 if (!SWIG_IsOK(res2)) {
29909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29910 }
29911 arg2 = reinterpret_cast< wxWindow * >(argp2);
29912 if (obj2) {
29913 ecode3 = SWIG_AsVal_int(obj2, &val3);
29914 if (!SWIG_IsOK(ecode3)) {
29915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29916 }
29917 arg3 = static_cast< int >(val3);
29918 }
29919 if (obj3) {
29920 {
29921 arg4 = &temp4;
29922 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29923 }
29924 }
29925 if (obj4) {
29926 {
29927 arg5 = &temp5;
29928 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29929 }
29930 }
29931 if (obj5) {
29932 ecode6 = SWIG_AsVal_long(obj5, &val6);
29933 if (!SWIG_IsOK(ecode6)) {
29934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29935 }
29936 arg6 = static_cast< long >(val6);
29937 }
29938 if (obj6) {
29939 {
29940 arg7 = wxString_in_helper(obj6);
29941 if (arg7 == NULL) SWIG_fail;
29942 temp7 = true;
29943 }
29944 }
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29948 wxPyEndAllowThreads(__tstate);
29949 if (PyErr_Occurred()) SWIG_fail;
29950 }
29951 {
29952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29953 }
29954 {
29955 if (temp7)
29956 delete arg7;
29957 }
29958 return resultobj;
29959 fail:
29960 {
29961 if (temp7)
29962 delete arg7;
29963 }
29964 return NULL;
29965 }
29966
29967
29968 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29969 PyObject *resultobj = 0;
29970 wxWindow *arg1 = (wxWindow *) 0 ;
29971 bool arg2 = (bool) false ;
29972 bool result;
29973 void *argp1 = 0 ;
29974 int res1 = 0 ;
29975 bool val2 ;
29976 int ecode2 = 0 ;
29977 PyObject * obj0 = 0 ;
29978 PyObject * obj1 = 0 ;
29979 char * kwnames[] = {
29980 (char *) "self",(char *) "force", NULL
29981 };
29982
29983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29985 if (!SWIG_IsOK(res1)) {
29986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29987 }
29988 arg1 = reinterpret_cast< wxWindow * >(argp1);
29989 if (obj1) {
29990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29991 if (!SWIG_IsOK(ecode2)) {
29992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29993 }
29994 arg2 = static_cast< bool >(val2);
29995 }
29996 {
29997 PyThreadState* __tstate = wxPyBeginAllowThreads();
29998 result = (bool)(arg1)->Close(arg2);
29999 wxPyEndAllowThreads(__tstate);
30000 if (PyErr_Occurred()) SWIG_fail;
30001 }
30002 {
30003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30004 }
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30012 PyObject *resultobj = 0;
30013 wxWindow *arg1 = (wxWindow *) 0 ;
30014 bool result;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 PyObject *swig_obj[1] ;
30018
30019 if (!args) SWIG_fail;
30020 swig_obj[0] = args;
30021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30022 if (!SWIG_IsOK(res1)) {
30023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30024 }
30025 arg1 = reinterpret_cast< wxWindow * >(argp1);
30026 {
30027 PyThreadState* __tstate = wxPyBeginAllowThreads();
30028 result = (bool)(arg1)->Destroy();
30029 wxPyEndAllowThreads(__tstate);
30030 if (PyErr_Occurred()) SWIG_fail;
30031 }
30032 {
30033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30034 }
30035 return resultobj;
30036 fail:
30037 return NULL;
30038 }
30039
30040
30041 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30042 PyObject *resultobj = 0;
30043 wxWindow *arg1 = (wxWindow *) 0 ;
30044 bool result;
30045 void *argp1 = 0 ;
30046 int res1 = 0 ;
30047 PyObject *swig_obj[1] ;
30048
30049 if (!args) SWIG_fail;
30050 swig_obj[0] = args;
30051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30052 if (!SWIG_IsOK(res1)) {
30053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30054 }
30055 arg1 = reinterpret_cast< wxWindow * >(argp1);
30056 {
30057 PyThreadState* __tstate = wxPyBeginAllowThreads();
30058 result = (bool)(arg1)->DestroyChildren();
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 {
30063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30064 }
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 PyObject *resultobj = 0;
30073 wxWindow *arg1 = (wxWindow *) 0 ;
30074 bool result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 PyObject *swig_obj[1] ;
30078
30079 if (!args) SWIG_fail;
30080 swig_obj[0] = args;
30081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30084 }
30085 arg1 = reinterpret_cast< wxWindow * >(argp1);
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 {
30093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30094 }
30095 return resultobj;
30096 fail:
30097 return NULL;
30098 }
30099
30100
30101 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30102 PyObject *resultobj = 0;
30103 wxWindow *arg1 = (wxWindow *) 0 ;
30104 wxString *arg2 = 0 ;
30105 void *argp1 = 0 ;
30106 int res1 = 0 ;
30107 bool temp2 = false ;
30108 PyObject * obj0 = 0 ;
30109 PyObject * obj1 = 0 ;
30110 char * kwnames[] = {
30111 (char *) "self",(char *) "label", NULL
30112 };
30113
30114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30116 if (!SWIG_IsOK(res1)) {
30117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30118 }
30119 arg1 = reinterpret_cast< wxWindow * >(argp1);
30120 {
30121 arg2 = wxString_in_helper(obj1);
30122 if (arg2 == NULL) SWIG_fail;
30123 temp2 = true;
30124 }
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 (arg1)->SetLabel((wxString const &)*arg2);
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 resultobj = SWIG_Py_Void();
30132 {
30133 if (temp2)
30134 delete arg2;
30135 }
30136 return resultobj;
30137 fail:
30138 {
30139 if (temp2)
30140 delete arg2;
30141 }
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30147 PyObject *resultobj = 0;
30148 wxWindow *arg1 = (wxWindow *) 0 ;
30149 wxString result;
30150 void *argp1 = 0 ;
30151 int res1 = 0 ;
30152 PyObject *swig_obj[1] ;
30153
30154 if (!args) SWIG_fail;
30155 swig_obj[0] = args;
30156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30157 if (!SWIG_IsOK(res1)) {
30158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30159 }
30160 arg1 = reinterpret_cast< wxWindow * >(argp1);
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 result = ((wxWindow const *)arg1)->GetLabel();
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 {
30168 #if wxUSE_UNICODE
30169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30170 #else
30171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30172 #endif
30173 }
30174 return resultobj;
30175 fail:
30176 return NULL;
30177 }
30178
30179
30180 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30181 PyObject *resultobj = 0;
30182 wxWindow *arg1 = (wxWindow *) 0 ;
30183 wxString *arg2 = 0 ;
30184 void *argp1 = 0 ;
30185 int res1 = 0 ;
30186 bool temp2 = false ;
30187 PyObject * obj0 = 0 ;
30188 PyObject * obj1 = 0 ;
30189 char * kwnames[] = {
30190 (char *) "self",(char *) "name", NULL
30191 };
30192
30193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30195 if (!SWIG_IsOK(res1)) {
30196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30197 }
30198 arg1 = reinterpret_cast< wxWindow * >(argp1);
30199 {
30200 arg2 = wxString_in_helper(obj1);
30201 if (arg2 == NULL) SWIG_fail;
30202 temp2 = true;
30203 }
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->SetName((wxString const &)*arg2);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_Py_Void();
30211 {
30212 if (temp2)
30213 delete arg2;
30214 }
30215 return resultobj;
30216 fail:
30217 {
30218 if (temp2)
30219 delete arg2;
30220 }
30221 return NULL;
30222 }
30223
30224
30225 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30226 PyObject *resultobj = 0;
30227 wxWindow *arg1 = (wxWindow *) 0 ;
30228 wxString result;
30229 void *argp1 = 0 ;
30230 int res1 = 0 ;
30231 PyObject *swig_obj[1] ;
30232
30233 if (!args) SWIG_fail;
30234 swig_obj[0] = args;
30235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30236 if (!SWIG_IsOK(res1)) {
30237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30238 }
30239 arg1 = reinterpret_cast< wxWindow * >(argp1);
30240 {
30241 PyThreadState* __tstate = wxPyBeginAllowThreads();
30242 result = ((wxWindow const *)arg1)->GetName();
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 {
30247 #if wxUSE_UNICODE
30248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30249 #else
30250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30251 #endif
30252 }
30253 return resultobj;
30254 fail:
30255 return NULL;
30256 }
30257
30258
30259 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30260 PyObject *resultobj = 0;
30261 wxWindow *arg1 = (wxWindow *) 0 ;
30262 wxWindowVariant arg2 ;
30263 void *argp1 = 0 ;
30264 int res1 = 0 ;
30265 int val2 ;
30266 int ecode2 = 0 ;
30267 PyObject * obj0 = 0 ;
30268 PyObject * obj1 = 0 ;
30269 char * kwnames[] = {
30270 (char *) "self",(char *) "variant", NULL
30271 };
30272
30273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30275 if (!SWIG_IsOK(res1)) {
30276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30277 }
30278 arg1 = reinterpret_cast< wxWindow * >(argp1);
30279 ecode2 = SWIG_AsVal_int(obj1, &val2);
30280 if (!SWIG_IsOK(ecode2)) {
30281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30282 }
30283 arg2 = static_cast< wxWindowVariant >(val2);
30284 {
30285 PyThreadState* __tstate = wxPyBeginAllowThreads();
30286 (arg1)->SetWindowVariant(arg2);
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 resultobj = SWIG_Py_Void();
30291 return resultobj;
30292 fail:
30293 return NULL;
30294 }
30295
30296
30297 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30298 PyObject *resultobj = 0;
30299 wxWindow *arg1 = (wxWindow *) 0 ;
30300 wxWindowVariant result;
30301 void *argp1 = 0 ;
30302 int res1 = 0 ;
30303 PyObject *swig_obj[1] ;
30304
30305 if (!args) SWIG_fail;
30306 swig_obj[0] = args;
30307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30308 if (!SWIG_IsOK(res1)) {
30309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30310 }
30311 arg1 = reinterpret_cast< wxWindow * >(argp1);
30312 {
30313 PyThreadState* __tstate = wxPyBeginAllowThreads();
30314 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30315 wxPyEndAllowThreads(__tstate);
30316 if (PyErr_Occurred()) SWIG_fail;
30317 }
30318 resultobj = SWIG_From_int(static_cast< int >(result));
30319 return resultobj;
30320 fail:
30321 return NULL;
30322 }
30323
30324
30325 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30326 PyObject *resultobj = 0;
30327 wxWindow *arg1 = (wxWindow *) 0 ;
30328 int arg2 ;
30329 void *argp1 = 0 ;
30330 int res1 = 0 ;
30331 int val2 ;
30332 int ecode2 = 0 ;
30333 PyObject * obj0 = 0 ;
30334 PyObject * obj1 = 0 ;
30335 char * kwnames[] = {
30336 (char *) "self",(char *) "winid", NULL
30337 };
30338
30339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30341 if (!SWIG_IsOK(res1)) {
30342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30343 }
30344 arg1 = reinterpret_cast< wxWindow * >(argp1);
30345 ecode2 = SWIG_AsVal_int(obj1, &val2);
30346 if (!SWIG_IsOK(ecode2)) {
30347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30348 }
30349 arg2 = static_cast< int >(val2);
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 (arg1)->SetId(arg2);
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 resultobj = SWIG_Py_Void();
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30364 PyObject *resultobj = 0;
30365 wxWindow *arg1 = (wxWindow *) 0 ;
30366 int result;
30367 void *argp1 = 0 ;
30368 int res1 = 0 ;
30369 PyObject *swig_obj[1] ;
30370
30371 if (!args) SWIG_fail;
30372 swig_obj[0] = args;
30373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30374 if (!SWIG_IsOK(res1)) {
30375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30376 }
30377 arg1 = reinterpret_cast< wxWindow * >(argp1);
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (int)((wxWindow const *)arg1)->GetId();
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_From_int(static_cast< int >(result));
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30392 PyObject *resultobj = 0;
30393 int result;
30394
30395 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30396 {
30397 PyThreadState* __tstate = wxPyBeginAllowThreads();
30398 result = (int)wxWindow::NewControlId();
30399 wxPyEndAllowThreads(__tstate);
30400 if (PyErr_Occurred()) SWIG_fail;
30401 }
30402 resultobj = SWIG_From_int(static_cast< int >(result));
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30410 PyObject *resultobj = 0;
30411 int arg1 ;
30412 int result;
30413 int val1 ;
30414 int ecode1 = 0 ;
30415 PyObject * obj0 = 0 ;
30416 char * kwnames[] = {
30417 (char *) "winid", NULL
30418 };
30419
30420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30421 ecode1 = SWIG_AsVal_int(obj0, &val1);
30422 if (!SWIG_IsOK(ecode1)) {
30423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30424 }
30425 arg1 = static_cast< int >(val1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 result = (int)wxWindow::NextControlId(arg1);
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_From_int(static_cast< int >(result));
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj = 0;
30441 int arg1 ;
30442 int result;
30443 int val1 ;
30444 int ecode1 = 0 ;
30445 PyObject * obj0 = 0 ;
30446 char * kwnames[] = {
30447 (char *) "winid", NULL
30448 };
30449
30450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30451 ecode1 = SWIG_AsVal_int(obj0, &val1);
30452 if (!SWIG_IsOK(ecode1)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30454 }
30455 arg1 = static_cast< int >(val1);
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 result = (int)wxWindow::PrevControlId(arg1);
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_From_int(static_cast< int >(result));
30463 return resultobj;
30464 fail:
30465 return NULL;
30466 }
30467
30468
30469 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30470 PyObject *resultobj = 0;
30471 wxWindow *arg1 = (wxWindow *) 0 ;
30472 wxSize *arg2 = 0 ;
30473 void *argp1 = 0 ;
30474 int res1 = 0 ;
30475 wxSize temp2 ;
30476 PyObject * obj0 = 0 ;
30477 PyObject * obj1 = 0 ;
30478 char * kwnames[] = {
30479 (char *) "self",(char *) "size", NULL
30480 };
30481
30482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30484 if (!SWIG_IsOK(res1)) {
30485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30486 }
30487 arg1 = reinterpret_cast< wxWindow * >(argp1);
30488 {
30489 arg2 = &temp2;
30490 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30491 }
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 (arg1)->SetSize((wxSize const &)*arg2);
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 resultobj = SWIG_Py_Void();
30499 return resultobj;
30500 fail:
30501 return NULL;
30502 }
30503
30504
30505 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30506 PyObject *resultobj = 0;
30507 wxWindow *arg1 = (wxWindow *) 0 ;
30508 int arg2 ;
30509 int arg3 ;
30510 int arg4 ;
30511 int arg5 ;
30512 int arg6 = (int) wxSIZE_AUTO ;
30513 void *argp1 = 0 ;
30514 int res1 = 0 ;
30515 int val2 ;
30516 int ecode2 = 0 ;
30517 int val3 ;
30518 int ecode3 = 0 ;
30519 int val4 ;
30520 int ecode4 = 0 ;
30521 int val5 ;
30522 int ecode5 = 0 ;
30523 int val6 ;
30524 int ecode6 = 0 ;
30525 PyObject * obj0 = 0 ;
30526 PyObject * obj1 = 0 ;
30527 PyObject * obj2 = 0 ;
30528 PyObject * obj3 = 0 ;
30529 PyObject * obj4 = 0 ;
30530 PyObject * obj5 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 ecode2 = SWIG_AsVal_int(obj1, &val2);
30542 if (!SWIG_IsOK(ecode2)) {
30543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30544 }
30545 arg2 = static_cast< int >(val2);
30546 ecode3 = SWIG_AsVal_int(obj2, &val3);
30547 if (!SWIG_IsOK(ecode3)) {
30548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30549 }
30550 arg3 = static_cast< int >(val3);
30551 ecode4 = SWIG_AsVal_int(obj3, &val4);
30552 if (!SWIG_IsOK(ecode4)) {
30553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30554 }
30555 arg4 = static_cast< int >(val4);
30556 ecode5 = SWIG_AsVal_int(obj4, &val5);
30557 if (!SWIG_IsOK(ecode5)) {
30558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30559 }
30560 arg5 = static_cast< int >(val5);
30561 if (obj5) {
30562 ecode6 = SWIG_AsVal_int(obj5, &val6);
30563 if (!SWIG_IsOK(ecode6)) {
30564 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30565 }
30566 arg6 = static_cast< int >(val6);
30567 }
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj = 0;
30583 wxWindow *arg1 = (wxWindow *) 0 ;
30584 wxRect *arg2 = 0 ;
30585 int arg3 = (int) wxSIZE_AUTO ;
30586 void *argp1 = 0 ;
30587 int res1 = 0 ;
30588 wxRect temp2 ;
30589 int val3 ;
30590 int ecode3 = 0 ;
30591 PyObject * obj0 = 0 ;
30592 PyObject * obj1 = 0 ;
30593 PyObject * obj2 = 0 ;
30594 char * kwnames[] = {
30595 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30596 };
30597
30598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30600 if (!SWIG_IsOK(res1)) {
30601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30602 }
30603 arg1 = reinterpret_cast< wxWindow * >(argp1);
30604 {
30605 arg2 = &temp2;
30606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30607 }
30608 if (obj2) {
30609 ecode3 = SWIG_AsVal_int(obj2, &val3);
30610 if (!SWIG_IsOK(ecode3)) {
30611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30612 }
30613 arg3 = static_cast< int >(val3);
30614 }
30615 {
30616 PyThreadState* __tstate = wxPyBeginAllowThreads();
30617 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_Py_Void();
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30629 PyObject *resultobj = 0;
30630 wxWindow *arg1 = (wxWindow *) 0 ;
30631 int arg2 ;
30632 int arg3 ;
30633 void *argp1 = 0 ;
30634 int res1 = 0 ;
30635 int val2 ;
30636 int ecode2 = 0 ;
30637 int val3 ;
30638 int ecode3 = 0 ;
30639 PyObject * obj0 = 0 ;
30640 PyObject * obj1 = 0 ;
30641 PyObject * obj2 = 0 ;
30642 char * kwnames[] = {
30643 (char *) "self",(char *) "width",(char *) "height", NULL
30644 };
30645
30646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30650 }
30651 arg1 = reinterpret_cast< wxWindow * >(argp1);
30652 ecode2 = SWIG_AsVal_int(obj1, &val2);
30653 if (!SWIG_IsOK(ecode2)) {
30654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30655 }
30656 arg2 = static_cast< int >(val2);
30657 ecode3 = SWIG_AsVal_int(obj2, &val3);
30658 if (!SWIG_IsOK(ecode3)) {
30659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30660 }
30661 arg3 = static_cast< int >(val3);
30662 {
30663 PyThreadState* __tstate = wxPyBeginAllowThreads();
30664 (arg1)->SetSize(arg2,arg3);
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = SWIG_Py_Void();
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30676 PyObject *resultobj = 0;
30677 wxWindow *arg1 = (wxWindow *) 0 ;
30678 wxPoint *arg2 = 0 ;
30679 int arg3 = (int) wxSIZE_USE_EXISTING ;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 wxPoint temp2 ;
30683 int val3 ;
30684 int ecode3 = 0 ;
30685 PyObject * obj0 = 0 ;
30686 PyObject * obj1 = 0 ;
30687 PyObject * obj2 = 0 ;
30688 char * kwnames[] = {
30689 (char *) "self",(char *) "pt",(char *) "flags", NULL
30690 };
30691
30692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30694 if (!SWIG_IsOK(res1)) {
30695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30696 }
30697 arg1 = reinterpret_cast< wxWindow * >(argp1);
30698 {
30699 arg2 = &temp2;
30700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30701 }
30702 if (obj2) {
30703 ecode3 = SWIG_AsVal_int(obj2, &val3);
30704 if (!SWIG_IsOK(ecode3)) {
30705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30706 }
30707 arg3 = static_cast< int >(val3);
30708 }
30709 {
30710 PyThreadState* __tstate = wxPyBeginAllowThreads();
30711 (arg1)->Move((wxPoint const &)*arg2,arg3);
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 resultobj = SWIG_Py_Void();
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30723 PyObject *resultobj = 0;
30724 wxWindow *arg1 = (wxWindow *) 0 ;
30725 int arg2 ;
30726 int arg3 ;
30727 int arg4 = (int) wxSIZE_USE_EXISTING ;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 int val2 ;
30731 int ecode2 = 0 ;
30732 int val3 ;
30733 int ecode3 = 0 ;
30734 int val4 ;
30735 int ecode4 = 0 ;
30736 PyObject * obj0 = 0 ;
30737 PyObject * obj1 = 0 ;
30738 PyObject * obj2 = 0 ;
30739 PyObject * obj3 = 0 ;
30740 char * kwnames[] = {
30741 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30742 };
30743
30744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30748 }
30749 arg1 = reinterpret_cast< wxWindow * >(argp1);
30750 ecode2 = SWIG_AsVal_int(obj1, &val2);
30751 if (!SWIG_IsOK(ecode2)) {
30752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30753 }
30754 arg2 = static_cast< int >(val2);
30755 ecode3 = SWIG_AsVal_int(obj2, &val3);
30756 if (!SWIG_IsOK(ecode3)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30758 }
30759 arg3 = static_cast< int >(val3);
30760 if (obj3) {
30761 ecode4 = SWIG_AsVal_int(obj3, &val4);
30762 if (!SWIG_IsOK(ecode4)) {
30763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30764 }
30765 arg4 = static_cast< int >(val4);
30766 }
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 (arg1)->Move(arg2,arg3,arg4);
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_Py_Void();
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj = 0;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxSize const &arg2_defvalue = wxDefaultSize ;
30784 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30785 void *argp1 = 0 ;
30786 int res1 = 0 ;
30787 wxSize temp2 ;
30788 PyObject * obj0 = 0 ;
30789 PyObject * obj1 = 0 ;
30790 char * kwnames[] = {
30791 (char *) "self",(char *) "size", NULL
30792 };
30793
30794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30796 if (!SWIG_IsOK(res1)) {
30797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30798 }
30799 arg1 = reinterpret_cast< wxWindow * >(argp1);
30800 if (obj1) {
30801 {
30802 arg2 = &temp2;
30803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30804 }
30805 }
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_Py_Void();
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 void *argp1 = 0 ;
30823 int res1 = 0 ;
30824 PyObject *swig_obj[1] ;
30825
30826 if (!args) SWIG_fail;
30827 swig_obj[0] = args;
30828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30829 if (!SWIG_IsOK(res1)) {
30830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30831 }
30832 arg1 = reinterpret_cast< wxWindow * >(argp1);
30833 {
30834 PyThreadState* __tstate = wxPyBeginAllowThreads();
30835 (arg1)->Raise();
30836 wxPyEndAllowThreads(__tstate);
30837 if (PyErr_Occurred()) SWIG_fail;
30838 }
30839 resultobj = SWIG_Py_Void();
30840 return resultobj;
30841 fail:
30842 return NULL;
30843 }
30844
30845
30846 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30847 PyObject *resultobj = 0;
30848 wxWindow *arg1 = (wxWindow *) 0 ;
30849 void *argp1 = 0 ;
30850 int res1 = 0 ;
30851 PyObject *swig_obj[1] ;
30852
30853 if (!args) SWIG_fail;
30854 swig_obj[0] = args;
30855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30856 if (!SWIG_IsOK(res1)) {
30857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30858 }
30859 arg1 = reinterpret_cast< wxWindow * >(argp1);
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 (arg1)->Lower();
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 resultobj = SWIG_Py_Void();
30867 return resultobj;
30868 fail:
30869 return NULL;
30870 }
30871
30872
30873 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30874 PyObject *resultobj = 0;
30875 wxWindow *arg1 = (wxWindow *) 0 ;
30876 wxSize *arg2 = 0 ;
30877 void *argp1 = 0 ;
30878 int res1 = 0 ;
30879 wxSize temp2 ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char * kwnames[] = {
30883 (char *) "self",(char *) "size", NULL
30884 };
30885
30886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30890 }
30891 arg1 = reinterpret_cast< wxWindow * >(argp1);
30892 {
30893 arg2 = &temp2;
30894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30895 }
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 (arg1)->SetClientSize((wxSize const &)*arg2);
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 resultobj = SWIG_Py_Void();
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 int arg2 ;
30913 int arg3 ;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 int val2 ;
30917 int ecode2 = 0 ;
30918 int val3 ;
30919 int ecode3 = 0 ;
30920 PyObject * obj0 = 0 ;
30921 PyObject * obj1 = 0 ;
30922 PyObject * obj2 = 0 ;
30923 char * kwnames[] = {
30924 (char *) "self",(char *) "width",(char *) "height", NULL
30925 };
30926
30927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30931 }
30932 arg1 = reinterpret_cast< wxWindow * >(argp1);
30933 ecode2 = SWIG_AsVal_int(obj1, &val2);
30934 if (!SWIG_IsOK(ecode2)) {
30935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30936 }
30937 arg2 = static_cast< int >(val2);
30938 ecode3 = SWIG_AsVal_int(obj2, &val3);
30939 if (!SWIG_IsOK(ecode3)) {
30940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30941 }
30942 arg3 = static_cast< int >(val3);
30943 {
30944 PyThreadState* __tstate = wxPyBeginAllowThreads();
30945 (arg1)->SetClientSize(arg2,arg3);
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 resultobj = SWIG_Py_Void();
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj = 0;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxRect *arg2 = 0 ;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 wxRect temp2 ;
30963 PyObject * obj0 = 0 ;
30964 PyObject * obj1 = 0 ;
30965 char * kwnames[] = {
30966 (char *) "self",(char *) "rect", NULL
30967 };
30968
30969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30971 if (!SWIG_IsOK(res1)) {
30972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30973 }
30974 arg1 = reinterpret_cast< wxWindow * >(argp1);
30975 {
30976 arg2 = &temp2;
30977 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30978 }
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 (arg1)->SetClientSize((wxRect const &)*arg2);
30982 wxPyEndAllowThreads(__tstate);
30983 if (PyErr_Occurred()) SWIG_fail;
30984 }
30985 resultobj = SWIG_Py_Void();
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30993 PyObject *resultobj = 0;
30994 wxWindow *arg1 = (wxWindow *) 0 ;
30995 wxPoint result;
30996 void *argp1 = 0 ;
30997 int res1 = 0 ;
30998 PyObject *swig_obj[1] ;
30999
31000 if (!args) SWIG_fail;
31001 swig_obj[0] = args;
31002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31003 if (!SWIG_IsOK(res1)) {
31004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31005 }
31006 arg1 = reinterpret_cast< wxWindow * >(argp1);
31007 {
31008 PyThreadState* __tstate = wxPyBeginAllowThreads();
31009 result = ((wxWindow const *)arg1)->GetPosition();
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31021 PyObject *resultobj = 0;
31022 wxWindow *arg1 = (wxWindow *) 0 ;
31023 int *arg2 = (int *) 0 ;
31024 int *arg3 = (int *) 0 ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 int temp2 ;
31028 int res2 = SWIG_TMPOBJ ;
31029 int temp3 ;
31030 int res3 = SWIG_TMPOBJ ;
31031 PyObject *swig_obj[1] ;
31032
31033 arg2 = &temp2;
31034 arg3 = &temp3;
31035 if (!args) SWIG_fail;
31036 swig_obj[0] = args;
31037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31038 if (!SWIG_IsOK(res1)) {
31039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31040 }
31041 arg1 = reinterpret_cast< wxWindow * >(argp1);
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 resultobj = SWIG_Py_Void();
31049 if (SWIG_IsTmpObj(res2)) {
31050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31051 } else {
31052 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31054 }
31055 if (SWIG_IsTmpObj(res3)) {
31056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31057 } else {
31058 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31060 }
31061 return resultobj;
31062 fail:
31063 return NULL;
31064 }
31065
31066
31067 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31068 PyObject *resultobj = 0;
31069 wxWindow *arg1 = (wxWindow *) 0 ;
31070 wxPoint result;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 PyObject *swig_obj[1] ;
31074
31075 if (!args) SWIG_fail;
31076 swig_obj[0] = args;
31077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31078 if (!SWIG_IsOK(res1)) {
31079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31080 }
31081 arg1 = reinterpret_cast< wxWindow * >(argp1);
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 result = ((wxWindow const *)arg1)->GetScreenPosition();
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31089 return resultobj;
31090 fail:
31091 return NULL;
31092 }
31093
31094
31095 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31096 PyObject *resultobj = 0;
31097 wxWindow *arg1 = (wxWindow *) 0 ;
31098 int *arg2 = (int *) 0 ;
31099 int *arg3 = (int *) 0 ;
31100 void *argp1 = 0 ;
31101 int res1 = 0 ;
31102 int temp2 ;
31103 int res2 = SWIG_TMPOBJ ;
31104 int temp3 ;
31105 int res3 = SWIG_TMPOBJ ;
31106 PyObject *swig_obj[1] ;
31107
31108 arg2 = &temp2;
31109 arg3 = &temp3;
31110 if (!args) SWIG_fail;
31111 swig_obj[0] = args;
31112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31113 if (!SWIG_IsOK(res1)) {
31114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31115 }
31116 arg1 = reinterpret_cast< wxWindow * >(argp1);
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31120 wxPyEndAllowThreads(__tstate);
31121 if (PyErr_Occurred()) SWIG_fail;
31122 }
31123 resultobj = SWIG_Py_Void();
31124 if (SWIG_IsTmpObj(res2)) {
31125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31126 } else {
31127 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31129 }
31130 if (SWIG_IsTmpObj(res3)) {
31131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31132 } else {
31133 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31135 }
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31143 PyObject *resultobj = 0;
31144 wxWindow *arg1 = (wxWindow *) 0 ;
31145 wxRect result;
31146 void *argp1 = 0 ;
31147 int res1 = 0 ;
31148 PyObject *swig_obj[1] ;
31149
31150 if (!args) SWIG_fail;
31151 swig_obj[0] = args;
31152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31153 if (!SWIG_IsOK(res1)) {
31154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31155 }
31156 arg1 = reinterpret_cast< wxWindow * >(argp1);
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 result = ((wxWindow const *)arg1)->GetScreenRect();
31160 wxPyEndAllowThreads(__tstate);
31161 if (PyErr_Occurred()) SWIG_fail;
31162 }
31163 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31164 return resultobj;
31165 fail:
31166 return NULL;
31167 }
31168
31169
31170 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31171 PyObject *resultobj = 0;
31172 wxWindow *arg1 = (wxWindow *) 0 ;
31173 wxSize result;
31174 void *argp1 = 0 ;
31175 int res1 = 0 ;
31176 PyObject *swig_obj[1] ;
31177
31178 if (!args) SWIG_fail;
31179 swig_obj[0] = args;
31180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31183 }
31184 arg1 = reinterpret_cast< wxWindow * >(argp1);
31185 {
31186 PyThreadState* __tstate = wxPyBeginAllowThreads();
31187 result = ((wxWindow const *)arg1)->GetSize();
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31192 return resultobj;
31193 fail:
31194 return NULL;
31195 }
31196
31197
31198 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31199 PyObject *resultobj = 0;
31200 wxWindow *arg1 = (wxWindow *) 0 ;
31201 int *arg2 = (int *) 0 ;
31202 int *arg3 = (int *) 0 ;
31203 void *argp1 = 0 ;
31204 int res1 = 0 ;
31205 int temp2 ;
31206 int res2 = SWIG_TMPOBJ ;
31207 int temp3 ;
31208 int res3 = SWIG_TMPOBJ ;
31209 PyObject *swig_obj[1] ;
31210
31211 arg2 = &temp2;
31212 arg3 = &temp3;
31213 if (!args) SWIG_fail;
31214 swig_obj[0] = args;
31215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31216 if (!SWIG_IsOK(res1)) {
31217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31218 }
31219 arg1 = reinterpret_cast< wxWindow * >(argp1);
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 resultobj = SWIG_Py_Void();
31227 if (SWIG_IsTmpObj(res2)) {
31228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31229 } else {
31230 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31232 }
31233 if (SWIG_IsTmpObj(res3)) {
31234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31235 } else {
31236 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31238 }
31239 return resultobj;
31240 fail:
31241 return NULL;
31242 }
31243
31244
31245 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31246 PyObject *resultobj = 0;
31247 wxWindow *arg1 = (wxWindow *) 0 ;
31248 wxRect result;
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_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31258 }
31259 arg1 = reinterpret_cast< wxWindow * >(argp1);
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = ((wxWindow const *)arg1)->GetRect();
31263 wxPyEndAllowThreads(__tstate);
31264 if (PyErr_Occurred()) SWIG_fail;
31265 }
31266 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31267 return resultobj;
31268 fail:
31269 return NULL;
31270 }
31271
31272
31273 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31274 PyObject *resultobj = 0;
31275 wxWindow *arg1 = (wxWindow *) 0 ;
31276 wxSize result;
31277 void *argp1 = 0 ;
31278 int res1 = 0 ;
31279 PyObject *swig_obj[1] ;
31280
31281 if (!args) SWIG_fail;
31282 swig_obj[0] = args;
31283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31284 if (!SWIG_IsOK(res1)) {
31285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31286 }
31287 arg1 = reinterpret_cast< wxWindow * >(argp1);
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = ((wxWindow const *)arg1)->GetClientSize();
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31302 PyObject *resultobj = 0;
31303 wxWindow *arg1 = (wxWindow *) 0 ;
31304 int *arg2 = (int *) 0 ;
31305 int *arg3 = (int *) 0 ;
31306 void *argp1 = 0 ;
31307 int res1 = 0 ;
31308 int temp2 ;
31309 int res2 = SWIG_TMPOBJ ;
31310 int temp3 ;
31311 int res3 = SWIG_TMPOBJ ;
31312 PyObject *swig_obj[1] ;
31313
31314 arg2 = &temp2;
31315 arg3 = &temp3;
31316 if (!args) SWIG_fail;
31317 swig_obj[0] = args;
31318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31319 if (!SWIG_IsOK(res1)) {
31320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31321 }
31322 arg1 = reinterpret_cast< wxWindow * >(argp1);
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31326 wxPyEndAllowThreads(__tstate);
31327 if (PyErr_Occurred()) SWIG_fail;
31328 }
31329 resultobj = SWIG_Py_Void();
31330 if (SWIG_IsTmpObj(res2)) {
31331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31332 } else {
31333 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31335 }
31336 if (SWIG_IsTmpObj(res3)) {
31337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31338 } else {
31339 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31341 }
31342 return resultobj;
31343 fail:
31344 return NULL;
31345 }
31346
31347
31348 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31349 PyObject *resultobj = 0;
31350 wxWindow *arg1 = (wxWindow *) 0 ;
31351 wxPoint result;
31352 void *argp1 = 0 ;
31353 int res1 = 0 ;
31354 PyObject *swig_obj[1] ;
31355
31356 if (!args) SWIG_fail;
31357 swig_obj[0] = args;
31358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31359 if (!SWIG_IsOK(res1)) {
31360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31361 }
31362 arg1 = reinterpret_cast< wxWindow * >(argp1);
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31377 PyObject *resultobj = 0;
31378 wxWindow *arg1 = (wxWindow *) 0 ;
31379 wxRect result;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 PyObject *swig_obj[1] ;
31383
31384 if (!args) SWIG_fail;
31385 swig_obj[0] = args;
31386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31387 if (!SWIG_IsOK(res1)) {
31388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31389 }
31390 arg1 = reinterpret_cast< wxWindow * >(argp1);
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = ((wxWindow const *)arg1)->GetClientRect();
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31405 PyObject *resultobj = 0;
31406 wxWindow *arg1 = (wxWindow *) 0 ;
31407 wxSize result;
31408 void *argp1 = 0 ;
31409 int res1 = 0 ;
31410 PyObject *swig_obj[1] ;
31411
31412 if (!args) SWIG_fail;
31413 swig_obj[0] = args;
31414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31415 if (!SWIG_IsOK(res1)) {
31416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31417 }
31418 arg1 = reinterpret_cast< wxWindow * >(argp1);
31419 {
31420 PyThreadState* __tstate = wxPyBeginAllowThreads();
31421 result = ((wxWindow const *)arg1)->GetBestSize();
31422 wxPyEndAllowThreads(__tstate);
31423 if (PyErr_Occurred()) SWIG_fail;
31424 }
31425 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31433 PyObject *resultobj = 0;
31434 wxWindow *arg1 = (wxWindow *) 0 ;
31435 int *arg2 = (int *) 0 ;
31436 int *arg3 = (int *) 0 ;
31437 void *argp1 = 0 ;
31438 int res1 = 0 ;
31439 int temp2 ;
31440 int res2 = SWIG_TMPOBJ ;
31441 int temp3 ;
31442 int res3 = SWIG_TMPOBJ ;
31443 PyObject *swig_obj[1] ;
31444
31445 arg2 = &temp2;
31446 arg3 = &temp3;
31447 if (!args) SWIG_fail;
31448 swig_obj[0] = args;
31449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31450 if (!SWIG_IsOK(res1)) {
31451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31452 }
31453 arg1 = reinterpret_cast< wxWindow * >(argp1);
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 resultobj = SWIG_Py_Void();
31461 if (SWIG_IsTmpObj(res2)) {
31462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31463 } else {
31464 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31466 }
31467 if (SWIG_IsTmpObj(res3)) {
31468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31469 } else {
31470 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31472 }
31473 return resultobj;
31474 fail:
31475 return NULL;
31476 }
31477
31478
31479 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31480 PyObject *resultobj = 0;
31481 wxWindow *arg1 = (wxWindow *) 0 ;
31482 void *argp1 = 0 ;
31483 int res1 = 0 ;
31484 PyObject *swig_obj[1] ;
31485
31486 if (!args) SWIG_fail;
31487 swig_obj[0] = args;
31488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31489 if (!SWIG_IsOK(res1)) {
31490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31491 }
31492 arg1 = reinterpret_cast< wxWindow * >(argp1);
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 (arg1)->InvalidateBestSize();
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 resultobj = SWIG_Py_Void();
31500 return resultobj;
31501 fail:
31502 return NULL;
31503 }
31504
31505
31506 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj = 0;
31508 wxWindow *arg1 = (wxWindow *) 0 ;
31509 wxSize *arg2 = 0 ;
31510 void *argp1 = 0 ;
31511 int res1 = 0 ;
31512 wxSize temp2 ;
31513 PyObject * obj0 = 0 ;
31514 PyObject * obj1 = 0 ;
31515 char * kwnames[] = {
31516 (char *) "self",(char *) "size", NULL
31517 };
31518
31519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31521 if (!SWIG_IsOK(res1)) {
31522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31523 }
31524 arg1 = reinterpret_cast< wxWindow * >(argp1);
31525 {
31526 arg2 = &temp2;
31527 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31528 }
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 resultobj = SWIG_Py_Void();
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31543 PyObject *resultobj = 0;
31544 wxWindow *arg1 = (wxWindow *) 0 ;
31545 wxSize result;
31546 void *argp1 = 0 ;
31547 int res1 = 0 ;
31548 PyObject *swig_obj[1] ;
31549
31550 if (!args) SWIG_fail;
31551 swig_obj[0] = args;
31552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31553 if (!SWIG_IsOK(res1)) {
31554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31555 }
31556 arg1 = reinterpret_cast< wxWindow * >(argp1);
31557 {
31558 PyThreadState* __tstate = wxPyBeginAllowThreads();
31559 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31560 wxPyEndAllowThreads(__tstate);
31561 if (PyErr_Occurred()) SWIG_fail;
31562 }
31563 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31564 return resultobj;
31565 fail:
31566 return NULL;
31567 }
31568
31569
31570 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31571 PyObject *resultobj = 0;
31572 wxWindow *arg1 = (wxWindow *) 0 ;
31573 wxSize result;
31574 void *argp1 = 0 ;
31575 int res1 = 0 ;
31576 PyObject *swig_obj[1] ;
31577
31578 if (!args) SWIG_fail;
31579 swig_obj[0] = args;
31580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31581 if (!SWIG_IsOK(res1)) {
31582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31583 }
31584 arg1 = reinterpret_cast< wxWindow * >(argp1);
31585 {
31586 PyThreadState* __tstate = wxPyBeginAllowThreads();
31587 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31599 PyObject *resultobj = 0;
31600 wxWindow *arg1 = (wxWindow *) 0 ;
31601 int arg2 = (int) wxBOTH ;
31602 void *argp1 = 0 ;
31603 int res1 = 0 ;
31604 int val2 ;
31605 int ecode2 = 0 ;
31606 PyObject * obj0 = 0 ;
31607 PyObject * obj1 = 0 ;
31608 char * kwnames[] = {
31609 (char *) "self",(char *) "direction", NULL
31610 };
31611
31612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31614 if (!SWIG_IsOK(res1)) {
31615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31616 }
31617 arg1 = reinterpret_cast< wxWindow * >(argp1);
31618 if (obj1) {
31619 ecode2 = SWIG_AsVal_int(obj1, &val2);
31620 if (!SWIG_IsOK(ecode2)) {
31621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31622 }
31623 arg2 = static_cast< int >(val2);
31624 }
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 (arg1)->Center(arg2);
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 resultobj = SWIG_Py_Void();
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31639 PyObject *resultobj = 0;
31640 wxWindow *arg1 = (wxWindow *) 0 ;
31641 int arg2 = (int) wxBOTH ;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 int val2 ;
31645 int ecode2 = 0 ;
31646 PyObject * obj0 = 0 ;
31647 PyObject * obj1 = 0 ;
31648 char * kwnames[] = {
31649 (char *) "self",(char *) "dir", NULL
31650 };
31651
31652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31654 if (!SWIG_IsOK(res1)) {
31655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31656 }
31657 arg1 = reinterpret_cast< wxWindow * >(argp1);
31658 if (obj1) {
31659 ecode2 = SWIG_AsVal_int(obj1, &val2);
31660 if (!SWIG_IsOK(ecode2)) {
31661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31662 }
31663 arg2 = static_cast< int >(val2);
31664 }
31665 {
31666 PyThreadState* __tstate = wxPyBeginAllowThreads();
31667 (arg1)->CenterOnParent(arg2);
31668 wxPyEndAllowThreads(__tstate);
31669 if (PyErr_Occurred()) SWIG_fail;
31670 }
31671 resultobj = SWIG_Py_Void();
31672 return resultobj;
31673 fail:
31674 return NULL;
31675 }
31676
31677
31678 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31679 PyObject *resultobj = 0;
31680 wxWindow *arg1 = (wxWindow *) 0 ;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 PyObject *swig_obj[1] ;
31684
31685 if (!args) SWIG_fail;
31686 swig_obj[0] = args;
31687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31690 }
31691 arg1 = reinterpret_cast< wxWindow * >(argp1);
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 (arg1)->Fit();
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 resultobj = SWIG_Py_Void();
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31706 PyObject *resultobj = 0;
31707 wxWindow *arg1 = (wxWindow *) 0 ;
31708 void *argp1 = 0 ;
31709 int res1 = 0 ;
31710 PyObject *swig_obj[1] ;
31711
31712 if (!args) SWIG_fail;
31713 swig_obj[0] = args;
31714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31715 if (!SWIG_IsOK(res1)) {
31716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31717 }
31718 arg1 = reinterpret_cast< wxWindow * >(argp1);
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 (arg1)->FitInside();
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_Py_Void();
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31733 PyObject *resultobj = 0;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 int arg2 ;
31736 int arg3 ;
31737 int arg4 = (int) -1 ;
31738 int arg5 = (int) -1 ;
31739 int arg6 = (int) -1 ;
31740 int arg7 = (int) -1 ;
31741 void *argp1 = 0 ;
31742 int res1 = 0 ;
31743 int val2 ;
31744 int ecode2 = 0 ;
31745 int val3 ;
31746 int ecode3 = 0 ;
31747 int val4 ;
31748 int ecode4 = 0 ;
31749 int val5 ;
31750 int ecode5 = 0 ;
31751 int val6 ;
31752 int ecode6 = 0 ;
31753 int val7 ;
31754 int ecode7 = 0 ;
31755 PyObject * obj0 = 0 ;
31756 PyObject * obj1 = 0 ;
31757 PyObject * obj2 = 0 ;
31758 PyObject * obj3 = 0 ;
31759 PyObject * obj4 = 0 ;
31760 PyObject * obj5 = 0 ;
31761 PyObject * obj6 = 0 ;
31762 char * kwnames[] = {
31763 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31764 };
31765
31766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31768 if (!SWIG_IsOK(res1)) {
31769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31770 }
31771 arg1 = reinterpret_cast< wxWindow * >(argp1);
31772 ecode2 = SWIG_AsVal_int(obj1, &val2);
31773 if (!SWIG_IsOK(ecode2)) {
31774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31775 }
31776 arg2 = static_cast< int >(val2);
31777 ecode3 = SWIG_AsVal_int(obj2, &val3);
31778 if (!SWIG_IsOK(ecode3)) {
31779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31780 }
31781 arg3 = static_cast< int >(val3);
31782 if (obj3) {
31783 ecode4 = SWIG_AsVal_int(obj3, &val4);
31784 if (!SWIG_IsOK(ecode4)) {
31785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31786 }
31787 arg4 = static_cast< int >(val4);
31788 }
31789 if (obj4) {
31790 ecode5 = SWIG_AsVal_int(obj4, &val5);
31791 if (!SWIG_IsOK(ecode5)) {
31792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31793 }
31794 arg5 = static_cast< int >(val5);
31795 }
31796 if (obj5) {
31797 ecode6 = SWIG_AsVal_int(obj5, &val6);
31798 if (!SWIG_IsOK(ecode6)) {
31799 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31800 }
31801 arg6 = static_cast< int >(val6);
31802 }
31803 if (obj6) {
31804 ecode7 = SWIG_AsVal_int(obj6, &val7);
31805 if (!SWIG_IsOK(ecode7)) {
31806 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31807 }
31808 arg7 = static_cast< int >(val7);
31809 }
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_Py_Void();
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31824 PyObject *resultobj = 0;
31825 wxWindow *arg1 = (wxWindow *) 0 ;
31826 wxSize *arg2 = 0 ;
31827 wxSize const &arg3_defvalue = wxDefaultSize ;
31828 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31829 wxSize const &arg4_defvalue = wxDefaultSize ;
31830 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31831 void *argp1 = 0 ;
31832 int res1 = 0 ;
31833 wxSize temp2 ;
31834 wxSize temp3 ;
31835 wxSize temp4 ;
31836 PyObject * obj0 = 0 ;
31837 PyObject * obj1 = 0 ;
31838 PyObject * obj2 = 0 ;
31839 PyObject * obj3 = 0 ;
31840 char * kwnames[] = {
31841 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31842 };
31843
31844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31846 if (!SWIG_IsOK(res1)) {
31847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31848 }
31849 arg1 = reinterpret_cast< wxWindow * >(argp1);
31850 {
31851 arg2 = &temp2;
31852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31853 }
31854 if (obj2) {
31855 {
31856 arg3 = &temp3;
31857 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31858 }
31859 }
31860 if (obj3) {
31861 {
31862 arg4 = &temp4;
31863 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31864 }
31865 }
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_Py_Void();
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31880 PyObject *resultobj = 0;
31881 wxWindow *arg1 = (wxWindow *) 0 ;
31882 int arg2 ;
31883 int arg3 ;
31884 int arg4 = (int) -1 ;
31885 int arg5 = (int) -1 ;
31886 void *argp1 = 0 ;
31887 int res1 = 0 ;
31888 int val2 ;
31889 int ecode2 = 0 ;
31890 int val3 ;
31891 int ecode3 = 0 ;
31892 int val4 ;
31893 int ecode4 = 0 ;
31894 int val5 ;
31895 int ecode5 = 0 ;
31896 PyObject * obj0 = 0 ;
31897 PyObject * obj1 = 0 ;
31898 PyObject * obj2 = 0 ;
31899 PyObject * obj3 = 0 ;
31900 PyObject * obj4 = 0 ;
31901 char * kwnames[] = {
31902 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31903 };
31904
31905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31907 if (!SWIG_IsOK(res1)) {
31908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31909 }
31910 arg1 = reinterpret_cast< wxWindow * >(argp1);
31911 ecode2 = SWIG_AsVal_int(obj1, &val2);
31912 if (!SWIG_IsOK(ecode2)) {
31913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31914 }
31915 arg2 = static_cast< int >(val2);
31916 ecode3 = SWIG_AsVal_int(obj2, &val3);
31917 if (!SWIG_IsOK(ecode3)) {
31918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31919 }
31920 arg3 = static_cast< int >(val3);
31921 if (obj3) {
31922 ecode4 = SWIG_AsVal_int(obj3, &val4);
31923 if (!SWIG_IsOK(ecode4)) {
31924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31925 }
31926 arg4 = static_cast< int >(val4);
31927 }
31928 if (obj4) {
31929 ecode5 = SWIG_AsVal_int(obj4, &val5);
31930 if (!SWIG_IsOK(ecode5)) {
31931 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31932 }
31933 arg5 = static_cast< int >(val5);
31934 }
31935 {
31936 PyThreadState* __tstate = wxPyBeginAllowThreads();
31937 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31938 wxPyEndAllowThreads(__tstate);
31939 if (PyErr_Occurred()) SWIG_fail;
31940 }
31941 resultobj = SWIG_Py_Void();
31942 return resultobj;
31943 fail:
31944 return NULL;
31945 }
31946
31947
31948 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31949 PyObject *resultobj = 0;
31950 wxWindow *arg1 = (wxWindow *) 0 ;
31951 wxSize *arg2 = 0 ;
31952 wxSize const &arg3_defvalue = wxDefaultSize ;
31953 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31954 void *argp1 = 0 ;
31955 int res1 = 0 ;
31956 wxSize temp2 ;
31957 wxSize temp3 ;
31958 PyObject * obj0 = 0 ;
31959 PyObject * obj1 = 0 ;
31960 PyObject * obj2 = 0 ;
31961 char * kwnames[] = {
31962 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31963 };
31964
31965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31967 if (!SWIG_IsOK(res1)) {
31968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31969 }
31970 arg1 = reinterpret_cast< wxWindow * >(argp1);
31971 {
31972 arg2 = &temp2;
31973 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31974 }
31975 if (obj2) {
31976 {
31977 arg3 = &temp3;
31978 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31979 }
31980 }
31981 {
31982 PyThreadState* __tstate = wxPyBeginAllowThreads();
31983 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 resultobj = SWIG_Py_Void();
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31995 PyObject *resultobj = 0;
31996 wxWindow *arg1 = (wxWindow *) 0 ;
31997 wxSize result;
31998 void *argp1 = 0 ;
31999 int res1 = 0 ;
32000 PyObject *swig_obj[1] ;
32001
32002 if (!args) SWIG_fail;
32003 swig_obj[0] = args;
32004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32005 if (!SWIG_IsOK(res1)) {
32006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32007 }
32008 arg1 = reinterpret_cast< wxWindow * >(argp1);
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 result = ((wxWindow const *)arg1)->GetMaxSize();
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32023 PyObject *resultobj = 0;
32024 wxWindow *arg1 = (wxWindow *) 0 ;
32025 wxSize result;
32026 void *argp1 = 0 ;
32027 int res1 = 0 ;
32028 PyObject *swig_obj[1] ;
32029
32030 if (!args) SWIG_fail;
32031 swig_obj[0] = args;
32032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32033 if (!SWIG_IsOK(res1)) {
32034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32035 }
32036 arg1 = reinterpret_cast< wxWindow * >(argp1);
32037 {
32038 PyThreadState* __tstate = wxPyBeginAllowThreads();
32039 result = ((wxWindow const *)arg1)->GetMinSize();
32040 wxPyEndAllowThreads(__tstate);
32041 if (PyErr_Occurred()) SWIG_fail;
32042 }
32043 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32044 return resultobj;
32045 fail:
32046 return NULL;
32047 }
32048
32049
32050 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32051 PyObject *resultobj = 0;
32052 wxWindow *arg1 = (wxWindow *) 0 ;
32053 wxSize *arg2 = 0 ;
32054 void *argp1 = 0 ;
32055 int res1 = 0 ;
32056 wxSize temp2 ;
32057 PyObject * obj0 = 0 ;
32058 PyObject * obj1 = 0 ;
32059 char * kwnames[] = {
32060 (char *) "self",(char *) "minSize", NULL
32061 };
32062
32063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32065 if (!SWIG_IsOK(res1)) {
32066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32067 }
32068 arg1 = reinterpret_cast< wxWindow * >(argp1);
32069 {
32070 arg2 = &temp2;
32071 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32072 }
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 (arg1)->SetMinSize((wxSize const &)*arg2);
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = SWIG_Py_Void();
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = 0;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 wxSize *arg2 = 0 ;
32090 void *argp1 = 0 ;
32091 int res1 = 0 ;
32092 wxSize temp2 ;
32093 PyObject * obj0 = 0 ;
32094 PyObject * obj1 = 0 ;
32095 char * kwnames[] = {
32096 (char *) "self",(char *) "maxSize", NULL
32097 };
32098
32099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32101 if (!SWIG_IsOK(res1)) {
32102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32103 }
32104 arg1 = reinterpret_cast< wxWindow * >(argp1);
32105 {
32106 arg2 = &temp2;
32107 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32108 }
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 (arg1)->SetMaxSize((wxSize const &)*arg2);
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_Py_Void();
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32123 PyObject *resultobj = 0;
32124 wxWindow *arg1 = (wxWindow *) 0 ;
32125 int result;
32126 void *argp1 = 0 ;
32127 int res1 = 0 ;
32128 PyObject *swig_obj[1] ;
32129
32130 if (!args) SWIG_fail;
32131 swig_obj[0] = args;
32132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32133 if (!SWIG_IsOK(res1)) {
32134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32135 }
32136 arg1 = reinterpret_cast< wxWindow * >(argp1);
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 resultobj = SWIG_From_int(static_cast< int >(result));
32144 return resultobj;
32145 fail:
32146 return NULL;
32147 }
32148
32149
32150 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32151 PyObject *resultobj = 0;
32152 wxWindow *arg1 = (wxWindow *) 0 ;
32153 int result;
32154 void *argp1 = 0 ;
32155 int res1 = 0 ;
32156 PyObject *swig_obj[1] ;
32157
32158 if (!args) SWIG_fail;
32159 swig_obj[0] = args;
32160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32161 if (!SWIG_IsOK(res1)) {
32162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32163 }
32164 arg1 = reinterpret_cast< wxWindow * >(argp1);
32165 {
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 resultobj = SWIG_From_int(static_cast< int >(result));
32172 return resultobj;
32173 fail:
32174 return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179 PyObject *resultobj = 0;
32180 wxWindow *arg1 = (wxWindow *) 0 ;
32181 int result;
32182 void *argp1 = 0 ;
32183 int res1 = 0 ;
32184 PyObject *swig_obj[1] ;
32185
32186 if (!args) SWIG_fail;
32187 swig_obj[0] = args;
32188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32189 if (!SWIG_IsOK(res1)) {
32190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32191 }
32192 arg1 = reinterpret_cast< wxWindow * >(argp1);
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 resultobj = SWIG_From_int(static_cast< int >(result));
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 int result;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 resultobj = SWIG_From_int(static_cast< int >(result));
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 wxSize *arg2 = 0 ;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 wxSize temp2 ;
32241 PyObject * obj0 = 0 ;
32242 PyObject * obj1 = 0 ;
32243 char * kwnames[] = {
32244 (char *) "self",(char *) "size", NULL
32245 };
32246
32247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32249 if (!SWIG_IsOK(res1)) {
32250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32251 }
32252 arg1 = reinterpret_cast< wxWindow * >(argp1);
32253 {
32254 arg2 = &temp2;
32255 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32256 }
32257 {
32258 PyThreadState* __tstate = wxPyBeginAllowThreads();
32259 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32260 wxPyEndAllowThreads(__tstate);
32261 if (PyErr_Occurred()) SWIG_fail;
32262 }
32263 resultobj = SWIG_Py_Void();
32264 return resultobj;
32265 fail:
32266 return NULL;
32267 }
32268
32269
32270 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32271 PyObject *resultobj = 0;
32272 wxWindow *arg1 = (wxWindow *) 0 ;
32273 int arg2 ;
32274 int arg3 ;
32275 void *argp1 = 0 ;
32276 int res1 = 0 ;
32277 int val2 ;
32278 int ecode2 = 0 ;
32279 int val3 ;
32280 int ecode3 = 0 ;
32281 PyObject * obj0 = 0 ;
32282 PyObject * obj1 = 0 ;
32283 PyObject * obj2 = 0 ;
32284 char * kwnames[] = {
32285 (char *) "self",(char *) "w",(char *) "h", NULL
32286 };
32287
32288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32290 if (!SWIG_IsOK(res1)) {
32291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32292 }
32293 arg1 = reinterpret_cast< wxWindow * >(argp1);
32294 ecode2 = SWIG_AsVal_int(obj1, &val2);
32295 if (!SWIG_IsOK(ecode2)) {
32296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32297 }
32298 arg2 = static_cast< int >(val2);
32299 ecode3 = SWIG_AsVal_int(obj2, &val3);
32300 if (!SWIG_IsOK(ecode3)) {
32301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32302 }
32303 arg3 = static_cast< int >(val3);
32304 {
32305 PyThreadState* __tstate = wxPyBeginAllowThreads();
32306 (arg1)->SetVirtualSize(arg2,arg3);
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 resultobj = SWIG_Py_Void();
32311 return resultobj;
32312 fail:
32313 return NULL;
32314 }
32315
32316
32317 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32318 PyObject *resultobj = 0;
32319 wxWindow *arg1 = (wxWindow *) 0 ;
32320 wxSize result;
32321 void *argp1 = 0 ;
32322 int res1 = 0 ;
32323 PyObject *swig_obj[1] ;
32324
32325 if (!args) SWIG_fail;
32326 swig_obj[0] = args;
32327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32328 if (!SWIG_IsOK(res1)) {
32329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32330 }
32331 arg1 = reinterpret_cast< wxWindow * >(argp1);
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 result = ((wxWindow const *)arg1)->GetVirtualSize();
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32339 return resultobj;
32340 fail:
32341 return NULL;
32342 }
32343
32344
32345 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32346 PyObject *resultobj = 0;
32347 wxWindow *arg1 = (wxWindow *) 0 ;
32348 int *arg2 = (int *) 0 ;
32349 int *arg3 = (int *) 0 ;
32350 void *argp1 = 0 ;
32351 int res1 = 0 ;
32352 int temp2 ;
32353 int res2 = SWIG_TMPOBJ ;
32354 int temp3 ;
32355 int res3 = SWIG_TMPOBJ ;
32356 PyObject *swig_obj[1] ;
32357
32358 arg2 = &temp2;
32359 arg3 = &temp3;
32360 if (!args) SWIG_fail;
32361 swig_obj[0] = args;
32362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32363 if (!SWIG_IsOK(res1)) {
32364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32365 }
32366 arg1 = reinterpret_cast< wxWindow * >(argp1);
32367 {
32368 PyThreadState* __tstate = wxPyBeginAllowThreads();
32369 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 resultobj = SWIG_Py_Void();
32374 if (SWIG_IsTmpObj(res2)) {
32375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32376 } else {
32377 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32379 }
32380 if (SWIG_IsTmpObj(res3)) {
32381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32382 } else {
32383 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32385 }
32386 return resultobj;
32387 fail:
32388 return NULL;
32389 }
32390
32391
32392 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32393 PyObject *resultobj = 0;
32394 wxWindow *arg1 = (wxWindow *) 0 ;
32395 wxSize result;
32396 void *argp1 = 0 ;
32397 int res1 = 0 ;
32398 PyObject *swig_obj[1] ;
32399
32400 if (!args) SWIG_fail;
32401 swig_obj[0] = args;
32402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32403 if (!SWIG_IsOK(res1)) {
32404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32405 }
32406 arg1 = reinterpret_cast< wxWindow * >(argp1);
32407 {
32408 PyThreadState* __tstate = wxPyBeginAllowThreads();
32409 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32410 wxPyEndAllowThreads(__tstate);
32411 if (PyErr_Occurred()) SWIG_fail;
32412 }
32413 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32414 return resultobj;
32415 fail:
32416 return NULL;
32417 }
32418
32419
32420 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32421 PyObject *resultobj = 0;
32422 wxWindow *arg1 = (wxWindow *) 0 ;
32423 bool arg2 = (bool) true ;
32424 bool result;
32425 void *argp1 = 0 ;
32426 int res1 = 0 ;
32427 bool val2 ;
32428 int ecode2 = 0 ;
32429 PyObject * obj0 = 0 ;
32430 PyObject * obj1 = 0 ;
32431 char * kwnames[] = {
32432 (char *) "self",(char *) "show", NULL
32433 };
32434
32435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32437 if (!SWIG_IsOK(res1)) {
32438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32439 }
32440 arg1 = reinterpret_cast< wxWindow * >(argp1);
32441 if (obj1) {
32442 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32443 if (!SWIG_IsOK(ecode2)) {
32444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32445 }
32446 arg2 = static_cast< bool >(val2);
32447 }
32448 {
32449 PyThreadState* __tstate = wxPyBeginAllowThreads();
32450 result = (bool)(arg1)->Show(arg2);
32451 wxPyEndAllowThreads(__tstate);
32452 if (PyErr_Occurred()) SWIG_fail;
32453 }
32454 {
32455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32456 }
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32464 PyObject *resultobj = 0;
32465 wxWindow *arg1 = (wxWindow *) 0 ;
32466 bool result;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 PyObject *swig_obj[1] ;
32470
32471 if (!args) SWIG_fail;
32472 swig_obj[0] = args;
32473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32476 }
32477 arg1 = reinterpret_cast< wxWindow * >(argp1);
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (bool)(arg1)->Hide();
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 {
32485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32486 }
32487 return resultobj;
32488 fail:
32489 return NULL;
32490 }
32491
32492
32493 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32494 PyObject *resultobj = 0;
32495 wxWindow *arg1 = (wxWindow *) 0 ;
32496 bool arg2 = (bool) true ;
32497 bool result;
32498 void *argp1 = 0 ;
32499 int res1 = 0 ;
32500 bool val2 ;
32501 int ecode2 = 0 ;
32502 PyObject * obj0 = 0 ;
32503 PyObject * obj1 = 0 ;
32504 char * kwnames[] = {
32505 (char *) "self",(char *) "enable", NULL
32506 };
32507
32508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32510 if (!SWIG_IsOK(res1)) {
32511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32512 }
32513 arg1 = reinterpret_cast< wxWindow * >(argp1);
32514 if (obj1) {
32515 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32516 if (!SWIG_IsOK(ecode2)) {
32517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32518 }
32519 arg2 = static_cast< bool >(val2);
32520 }
32521 {
32522 PyThreadState* __tstate = wxPyBeginAllowThreads();
32523 result = (bool)(arg1)->Enable(arg2);
32524 wxPyEndAllowThreads(__tstate);
32525 if (PyErr_Occurred()) SWIG_fail;
32526 }
32527 {
32528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32529 }
32530 return resultobj;
32531 fail:
32532 return NULL;
32533 }
32534
32535
32536 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32537 PyObject *resultobj = 0;
32538 wxWindow *arg1 = (wxWindow *) 0 ;
32539 bool result;
32540 void *argp1 = 0 ;
32541 int res1 = 0 ;
32542 PyObject *swig_obj[1] ;
32543
32544 if (!args) SWIG_fail;
32545 swig_obj[0] = args;
32546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32547 if (!SWIG_IsOK(res1)) {
32548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32549 }
32550 arg1 = reinterpret_cast< wxWindow * >(argp1);
32551 {
32552 PyThreadState* __tstate = wxPyBeginAllowThreads();
32553 result = (bool)(arg1)->Disable();
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 {
32558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32559 }
32560 return resultobj;
32561 fail:
32562 return NULL;
32563 }
32564
32565
32566 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32567 PyObject *resultobj = 0;
32568 wxWindow *arg1 = (wxWindow *) 0 ;
32569 bool result;
32570 void *argp1 = 0 ;
32571 int res1 = 0 ;
32572 PyObject *swig_obj[1] ;
32573
32574 if (!args) SWIG_fail;
32575 swig_obj[0] = args;
32576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32577 if (!SWIG_IsOK(res1)) {
32578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32579 }
32580 arg1 = reinterpret_cast< wxWindow * >(argp1);
32581 {
32582 PyThreadState* __tstate = wxPyBeginAllowThreads();
32583 result = (bool)((wxWindow const *)arg1)->IsShown();
32584 wxPyEndAllowThreads(__tstate);
32585 if (PyErr_Occurred()) SWIG_fail;
32586 }
32587 {
32588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32589 }
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32597 PyObject *resultobj = 0;
32598 wxWindow *arg1 = (wxWindow *) 0 ;
32599 bool result;
32600 void *argp1 = 0 ;
32601 int res1 = 0 ;
32602 PyObject *swig_obj[1] ;
32603
32604 if (!args) SWIG_fail;
32605 swig_obj[0] = args;
32606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32607 if (!SWIG_IsOK(res1)) {
32608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32609 }
32610 arg1 = reinterpret_cast< wxWindow * >(argp1);
32611 {
32612 PyThreadState* __tstate = wxPyBeginAllowThreads();
32613 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 {
32618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32619 }
32620 return resultobj;
32621 fail:
32622 return NULL;
32623 }
32624
32625
32626 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32627 PyObject *resultobj = 0;
32628 wxWindow *arg1 = (wxWindow *) 0 ;
32629 long arg2 ;
32630 void *argp1 = 0 ;
32631 int res1 = 0 ;
32632 long val2 ;
32633 int ecode2 = 0 ;
32634 PyObject * obj0 = 0 ;
32635 PyObject * obj1 = 0 ;
32636 char * kwnames[] = {
32637 (char *) "self",(char *) "style", NULL
32638 };
32639
32640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32642 if (!SWIG_IsOK(res1)) {
32643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32644 }
32645 arg1 = reinterpret_cast< wxWindow * >(argp1);
32646 ecode2 = SWIG_AsVal_long(obj1, &val2);
32647 if (!SWIG_IsOK(ecode2)) {
32648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32649 }
32650 arg2 = static_cast< long >(val2);
32651 {
32652 PyThreadState* __tstate = wxPyBeginAllowThreads();
32653 (arg1)->SetWindowStyleFlag(arg2);
32654 wxPyEndAllowThreads(__tstate);
32655 if (PyErr_Occurred()) SWIG_fail;
32656 }
32657 resultobj = SWIG_Py_Void();
32658 return resultobj;
32659 fail:
32660 return NULL;
32661 }
32662
32663
32664 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32665 PyObject *resultobj = 0;
32666 wxWindow *arg1 = (wxWindow *) 0 ;
32667 long result;
32668 void *argp1 = 0 ;
32669 int res1 = 0 ;
32670 PyObject *swig_obj[1] ;
32671
32672 if (!args) SWIG_fail;
32673 swig_obj[0] = args;
32674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32675 if (!SWIG_IsOK(res1)) {
32676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32677 }
32678 arg1 = reinterpret_cast< wxWindow * >(argp1);
32679 {
32680 PyThreadState* __tstate = wxPyBeginAllowThreads();
32681 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32682 wxPyEndAllowThreads(__tstate);
32683 if (PyErr_Occurred()) SWIG_fail;
32684 }
32685 resultobj = SWIG_From_long(static_cast< long >(result));
32686 return resultobj;
32687 fail:
32688 return NULL;
32689 }
32690
32691
32692 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32693 PyObject *resultobj = 0;
32694 wxWindow *arg1 = (wxWindow *) 0 ;
32695 int arg2 ;
32696 bool result;
32697 void *argp1 = 0 ;
32698 int res1 = 0 ;
32699 int val2 ;
32700 int ecode2 = 0 ;
32701 PyObject * obj0 = 0 ;
32702 PyObject * obj1 = 0 ;
32703 char * kwnames[] = {
32704 (char *) "self",(char *) "flag", NULL
32705 };
32706
32707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32709 if (!SWIG_IsOK(res1)) {
32710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32711 }
32712 arg1 = reinterpret_cast< wxWindow * >(argp1);
32713 ecode2 = SWIG_AsVal_int(obj1, &val2);
32714 if (!SWIG_IsOK(ecode2)) {
32715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32716 }
32717 arg2 = static_cast< int >(val2);
32718 {
32719 PyThreadState* __tstate = wxPyBeginAllowThreads();
32720 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32721 wxPyEndAllowThreads(__tstate);
32722 if (PyErr_Occurred()) SWIG_fail;
32723 }
32724 {
32725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32726 }
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32734 PyObject *resultobj = 0;
32735 wxWindow *arg1 = (wxWindow *) 0 ;
32736 bool result;
32737 void *argp1 = 0 ;
32738 int res1 = 0 ;
32739 PyObject *swig_obj[1] ;
32740
32741 if (!args) SWIG_fail;
32742 swig_obj[0] = args;
32743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32744 if (!SWIG_IsOK(res1)) {
32745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32746 }
32747 arg1 = reinterpret_cast< wxWindow * >(argp1);
32748 {
32749 PyThreadState* __tstate = wxPyBeginAllowThreads();
32750 result = (bool)((wxWindow const *)arg1)->IsRetained();
32751 wxPyEndAllowThreads(__tstate);
32752 if (PyErr_Occurred()) SWIG_fail;
32753 }
32754 {
32755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32756 }
32757 return resultobj;
32758 fail:
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32764 PyObject *resultobj = 0;
32765 wxWindow *arg1 = (wxWindow *) 0 ;
32766 long arg2 ;
32767 void *argp1 = 0 ;
32768 int res1 = 0 ;
32769 long val2 ;
32770 int ecode2 = 0 ;
32771 PyObject * obj0 = 0 ;
32772 PyObject * obj1 = 0 ;
32773 char * kwnames[] = {
32774 (char *) "self",(char *) "exStyle", NULL
32775 };
32776
32777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32779 if (!SWIG_IsOK(res1)) {
32780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32781 }
32782 arg1 = reinterpret_cast< wxWindow * >(argp1);
32783 ecode2 = SWIG_AsVal_long(obj1, &val2);
32784 if (!SWIG_IsOK(ecode2)) {
32785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32786 }
32787 arg2 = static_cast< long >(val2);
32788 {
32789 PyThreadState* __tstate = wxPyBeginAllowThreads();
32790 (arg1)->SetExtraStyle(arg2);
32791 wxPyEndAllowThreads(__tstate);
32792 if (PyErr_Occurred()) SWIG_fail;
32793 }
32794 resultobj = SWIG_Py_Void();
32795 return resultobj;
32796 fail:
32797 return NULL;
32798 }
32799
32800
32801 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32802 PyObject *resultobj = 0;
32803 wxWindow *arg1 = (wxWindow *) 0 ;
32804 long result;
32805 void *argp1 = 0 ;
32806 int res1 = 0 ;
32807 PyObject *swig_obj[1] ;
32808
32809 if (!args) SWIG_fail;
32810 swig_obj[0] = args;
32811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32812 if (!SWIG_IsOK(res1)) {
32813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32814 }
32815 arg1 = reinterpret_cast< wxWindow * >(argp1);
32816 {
32817 PyThreadState* __tstate = wxPyBeginAllowThreads();
32818 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32819 wxPyEndAllowThreads(__tstate);
32820 if (PyErr_Occurred()) SWIG_fail;
32821 }
32822 resultobj = SWIG_From_long(static_cast< long >(result));
32823 return resultobj;
32824 fail:
32825 return NULL;
32826 }
32827
32828
32829 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32830 PyObject *resultobj = 0;
32831 wxWindow *arg1 = (wxWindow *) 0 ;
32832 bool arg2 = (bool) true ;
32833 void *argp1 = 0 ;
32834 int res1 = 0 ;
32835 bool val2 ;
32836 int ecode2 = 0 ;
32837 PyObject * obj0 = 0 ;
32838 PyObject * obj1 = 0 ;
32839 char * kwnames[] = {
32840 (char *) "self",(char *) "modal", NULL
32841 };
32842
32843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32845 if (!SWIG_IsOK(res1)) {
32846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32847 }
32848 arg1 = reinterpret_cast< wxWindow * >(argp1);
32849 if (obj1) {
32850 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32851 if (!SWIG_IsOK(ecode2)) {
32852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32853 }
32854 arg2 = static_cast< bool >(val2);
32855 }
32856 {
32857 PyThreadState* __tstate = wxPyBeginAllowThreads();
32858 (arg1)->MakeModal(arg2);
32859 wxPyEndAllowThreads(__tstate);
32860 if (PyErr_Occurred()) SWIG_fail;
32861 }
32862 resultobj = SWIG_Py_Void();
32863 return resultobj;
32864 fail:
32865 return NULL;
32866 }
32867
32868
32869 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32870 PyObject *resultobj = 0;
32871 wxWindow *arg1 = (wxWindow *) 0 ;
32872 bool arg2 ;
32873 void *argp1 = 0 ;
32874 int res1 = 0 ;
32875 bool val2 ;
32876 int ecode2 = 0 ;
32877 PyObject * obj0 = 0 ;
32878 PyObject * obj1 = 0 ;
32879 char * kwnames[] = {
32880 (char *) "self",(char *) "enableTheme", NULL
32881 };
32882
32883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32885 if (!SWIG_IsOK(res1)) {
32886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32887 }
32888 arg1 = reinterpret_cast< wxWindow * >(argp1);
32889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32890 if (!SWIG_IsOK(ecode2)) {
32891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32892 }
32893 arg2 = static_cast< bool >(val2);
32894 {
32895 PyThreadState* __tstate = wxPyBeginAllowThreads();
32896 (arg1)->SetThemeEnabled(arg2);
32897 wxPyEndAllowThreads(__tstate);
32898 if (PyErr_Occurred()) SWIG_fail;
32899 }
32900 resultobj = SWIG_Py_Void();
32901 return resultobj;
32902 fail:
32903 return NULL;
32904 }
32905
32906
32907 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32908 PyObject *resultobj = 0;
32909 wxWindow *arg1 = (wxWindow *) 0 ;
32910 bool result;
32911 void *argp1 = 0 ;
32912 int res1 = 0 ;
32913 PyObject *swig_obj[1] ;
32914
32915 if (!args) SWIG_fail;
32916 swig_obj[0] = args;
32917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32918 if (!SWIG_IsOK(res1)) {
32919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32920 }
32921 arg1 = reinterpret_cast< wxWindow * >(argp1);
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32925 wxPyEndAllowThreads(__tstate);
32926 if (PyErr_Occurred()) SWIG_fail;
32927 }
32928 {
32929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32930 }
32931 return resultobj;
32932 fail:
32933 return NULL;
32934 }
32935
32936
32937 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32938 PyObject *resultobj = 0;
32939 wxWindow *arg1 = (wxWindow *) 0 ;
32940 void *argp1 = 0 ;
32941 int res1 = 0 ;
32942 PyObject *swig_obj[1] ;
32943
32944 if (!args) SWIG_fail;
32945 swig_obj[0] = args;
32946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 (arg1)->SetFocus();
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 resultobj = SWIG_Py_Void();
32958 return resultobj;
32959 fail:
32960 return NULL;
32961 }
32962
32963
32964 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 PyObject *resultobj = 0;
32966 wxWindow *arg1 = (wxWindow *) 0 ;
32967 void *argp1 = 0 ;
32968 int res1 = 0 ;
32969 PyObject *swig_obj[1] ;
32970
32971 if (!args) SWIG_fail;
32972 swig_obj[0] = args;
32973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32974 if (!SWIG_IsOK(res1)) {
32975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32976 }
32977 arg1 = reinterpret_cast< wxWindow * >(argp1);
32978 {
32979 PyThreadState* __tstate = wxPyBeginAllowThreads();
32980 (arg1)->SetFocusFromKbd();
32981 wxPyEndAllowThreads(__tstate);
32982 if (PyErr_Occurred()) SWIG_fail;
32983 }
32984 resultobj = SWIG_Py_Void();
32985 return resultobj;
32986 fail:
32987 return NULL;
32988 }
32989
32990
32991 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32992 PyObject *resultobj = 0;
32993 wxWindow *result = 0 ;
32994
32995 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32996 {
32997 if (!wxPyCheckForApp()) SWIG_fail;
32998 PyThreadState* __tstate = wxPyBeginAllowThreads();
32999 result = (wxWindow *)wxWindow::FindFocus();
33000 wxPyEndAllowThreads(__tstate);
33001 if (PyErr_Occurred()) SWIG_fail;
33002 }
33003 {
33004 resultobj = wxPyMake_wxObject(result, 0);
33005 }
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 bool result;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 PyObject *swig_obj[1] ;
33019
33020 if (!args) SWIG_fail;
33021 swig_obj[0] = args;
33022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33023 if (!SWIG_IsOK(res1)) {
33024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33025 }
33026 arg1 = reinterpret_cast< wxWindow * >(argp1);
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33030 wxPyEndAllowThreads(__tstate);
33031 if (PyErr_Occurred()) SWIG_fail;
33032 }
33033 {
33034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33035 }
33036 return resultobj;
33037 fail:
33038 return NULL;
33039 }
33040
33041
33042 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33043 PyObject *resultobj = 0;
33044 wxWindow *arg1 = (wxWindow *) 0 ;
33045 bool result;
33046 void *argp1 = 0 ;
33047 int res1 = 0 ;
33048 PyObject *swig_obj[1] ;
33049
33050 if (!args) SWIG_fail;
33051 swig_obj[0] = args;
33052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33053 if (!SWIG_IsOK(res1)) {
33054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33055 }
33056 arg1 = reinterpret_cast< wxWindow * >(argp1);
33057 {
33058 PyThreadState* __tstate = wxPyBeginAllowThreads();
33059 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 {
33064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33065 }
33066 return resultobj;
33067 fail:
33068 return NULL;
33069 }
33070
33071
33072 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33073 PyObject *resultobj = 0;
33074 wxWindow *arg1 = (wxWindow *) 0 ;
33075 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33076 bool result;
33077 void *argp1 = 0 ;
33078 int res1 = 0 ;
33079 int val2 ;
33080 int ecode2 = 0 ;
33081 PyObject * obj0 = 0 ;
33082 PyObject * obj1 = 0 ;
33083 char * kwnames[] = {
33084 (char *) "self",(char *) "flags", NULL
33085 };
33086
33087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33091 }
33092 arg1 = reinterpret_cast< wxWindow * >(argp1);
33093 if (obj1) {
33094 ecode2 = SWIG_AsVal_int(obj1, &val2);
33095 if (!SWIG_IsOK(ecode2)) {
33096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33097 }
33098 arg2 = static_cast< int >(val2);
33099 }
33100 {
33101 PyThreadState* __tstate = wxPyBeginAllowThreads();
33102 result = (bool)(arg1)->Navigate(arg2);
33103 wxPyEndAllowThreads(__tstate);
33104 if (PyErr_Occurred()) SWIG_fail;
33105 }
33106 {
33107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33108 }
33109 return resultobj;
33110 fail:
33111 return NULL;
33112 }
33113
33114
33115 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33116 PyObject *resultobj = 0;
33117 wxWindow *arg1 = (wxWindow *) 0 ;
33118 wxWindow *arg2 = (wxWindow *) 0 ;
33119 void *argp1 = 0 ;
33120 int res1 = 0 ;
33121 void *argp2 = 0 ;
33122 int res2 = 0 ;
33123 PyObject * obj0 = 0 ;
33124 PyObject * obj1 = 0 ;
33125 char * kwnames[] = {
33126 (char *) "self",(char *) "win", NULL
33127 };
33128
33129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33131 if (!SWIG_IsOK(res1)) {
33132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33133 }
33134 arg1 = reinterpret_cast< wxWindow * >(argp1);
33135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33136 if (!SWIG_IsOK(res2)) {
33137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33138 }
33139 arg2 = reinterpret_cast< wxWindow * >(argp2);
33140 {
33141 PyThreadState* __tstate = wxPyBeginAllowThreads();
33142 (arg1)->MoveAfterInTabOrder(arg2);
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 resultobj = SWIG_Py_Void();
33147 return resultobj;
33148 fail:
33149 return NULL;
33150 }
33151
33152
33153 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33154 PyObject *resultobj = 0;
33155 wxWindow *arg1 = (wxWindow *) 0 ;
33156 wxWindow *arg2 = (wxWindow *) 0 ;
33157 void *argp1 = 0 ;
33158 int res1 = 0 ;
33159 void *argp2 = 0 ;
33160 int res2 = 0 ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 char * kwnames[] = {
33164 (char *) "self",(char *) "win", NULL
33165 };
33166
33167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33169 if (!SWIG_IsOK(res1)) {
33170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33171 }
33172 arg1 = reinterpret_cast< wxWindow * >(argp1);
33173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res2)) {
33175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33176 }
33177 arg2 = reinterpret_cast< wxWindow * >(argp2);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 (arg1)->MoveBeforeInTabOrder(arg2);
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 resultobj = SWIG_Py_Void();
33185 return resultobj;
33186 fail:
33187 return NULL;
33188 }
33189
33190
33191 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33192 PyObject *resultobj = 0;
33193 wxWindow *arg1 = (wxWindow *) 0 ;
33194 PyObject *result = 0 ;
33195 void *argp1 = 0 ;
33196 int res1 = 0 ;
33197 PyObject *swig_obj[1] ;
33198
33199 if (!args) SWIG_fail;
33200 swig_obj[0] = args;
33201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33204 }
33205 arg1 = reinterpret_cast< wxWindow * >(argp1);
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 result = (PyObject *)wxWindow_GetChildren(arg1);
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 resultobj = result;
33213 return resultobj;
33214 fail:
33215 return NULL;
33216 }
33217
33218
33219 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33220 PyObject *resultobj = 0;
33221 wxWindow *arg1 = (wxWindow *) 0 ;
33222 wxWindow *result = 0 ;
33223 void *argp1 = 0 ;
33224 int res1 = 0 ;
33225 PyObject *swig_obj[1] ;
33226
33227 if (!args) SWIG_fail;
33228 swig_obj[0] = args;
33229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33230 if (!SWIG_IsOK(res1)) {
33231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33232 }
33233 arg1 = reinterpret_cast< wxWindow * >(argp1);
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33237 wxPyEndAllowThreads(__tstate);
33238 if (PyErr_Occurred()) SWIG_fail;
33239 }
33240 {
33241 resultobj = wxPyMake_wxObject(result, 0);
33242 }
33243 return resultobj;
33244 fail:
33245 return NULL;
33246 }
33247
33248
33249 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33250 PyObject *resultobj = 0;
33251 wxWindow *arg1 = (wxWindow *) 0 ;
33252 wxWindow *result = 0 ;
33253 void *argp1 = 0 ;
33254 int res1 = 0 ;
33255 PyObject *swig_obj[1] ;
33256
33257 if (!args) SWIG_fail;
33258 swig_obj[0] = args;
33259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33260 if (!SWIG_IsOK(res1)) {
33261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33262 }
33263 arg1 = reinterpret_cast< wxWindow * >(argp1);
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33267 wxPyEndAllowThreads(__tstate);
33268 if (PyErr_Occurred()) SWIG_fail;
33269 }
33270 {
33271 resultobj = wxPyMake_wxObject(result, 0);
33272 }
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 bool result;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 PyObject *swig_obj[1] ;
33286
33287 if (!args) SWIG_fail;
33288 swig_obj[0] = args;
33289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 {
33301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33302 }
33303 return resultobj;
33304 fail:
33305 return NULL;
33306 }
33307
33308
33309 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33310 PyObject *resultobj = 0;
33311 wxWindow *arg1 = (wxWindow *) 0 ;
33312 wxWindow *arg2 = (wxWindow *) 0 ;
33313 bool result;
33314 void *argp1 = 0 ;
33315 int res1 = 0 ;
33316 void *argp2 = 0 ;
33317 int res2 = 0 ;
33318 PyObject * obj0 = 0 ;
33319 PyObject * obj1 = 0 ;
33320 char * kwnames[] = {
33321 (char *) "self",(char *) "newParent", NULL
33322 };
33323
33324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33326 if (!SWIG_IsOK(res1)) {
33327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33328 }
33329 arg1 = reinterpret_cast< wxWindow * >(argp1);
33330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33331 if (!SWIG_IsOK(res2)) {
33332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33333 }
33334 arg2 = reinterpret_cast< wxWindow * >(argp2);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (bool)(arg1)->Reparent(arg2);
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33343 }
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33351 PyObject *resultobj = 0;
33352 wxWindow *arg1 = (wxWindow *) 0 ;
33353 wxWindow *arg2 = (wxWindow *) 0 ;
33354 void *argp1 = 0 ;
33355 int res1 = 0 ;
33356 void *argp2 = 0 ;
33357 int res2 = 0 ;
33358 PyObject * obj0 = 0 ;
33359 PyObject * obj1 = 0 ;
33360 char * kwnames[] = {
33361 (char *) "self",(char *) "child", NULL
33362 };
33363
33364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33366 if (!SWIG_IsOK(res1)) {
33367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33368 }
33369 arg1 = reinterpret_cast< wxWindow * >(argp1);
33370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33371 if (!SWIG_IsOK(res2)) {
33372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33373 }
33374 arg2 = reinterpret_cast< wxWindow * >(argp2);
33375 {
33376 PyThreadState* __tstate = wxPyBeginAllowThreads();
33377 (arg1)->AddChild(arg2);
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 resultobj = SWIG_Py_Void();
33382 return resultobj;
33383 fail:
33384 return NULL;
33385 }
33386
33387
33388 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33389 PyObject *resultobj = 0;
33390 wxWindow *arg1 = (wxWindow *) 0 ;
33391 wxWindow *arg2 = (wxWindow *) 0 ;
33392 void *argp1 = 0 ;
33393 int res1 = 0 ;
33394 void *argp2 = 0 ;
33395 int res2 = 0 ;
33396 PyObject * obj0 = 0 ;
33397 PyObject * obj1 = 0 ;
33398 char * kwnames[] = {
33399 (char *) "self",(char *) "child", NULL
33400 };
33401
33402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33404 if (!SWIG_IsOK(res1)) {
33405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33406 }
33407 arg1 = reinterpret_cast< wxWindow * >(argp1);
33408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33409 if (!SWIG_IsOK(res2)) {
33410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33411 }
33412 arg2 = reinterpret_cast< wxWindow * >(argp2);
33413 {
33414 PyThreadState* __tstate = wxPyBeginAllowThreads();
33415 (arg1)->RemoveChild(arg2);
33416 wxPyEndAllowThreads(__tstate);
33417 if (PyErr_Occurred()) SWIG_fail;
33418 }
33419 resultobj = SWIG_Py_Void();
33420 return resultobj;
33421 fail:
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33427 PyObject *resultobj = 0;
33428 wxWindow *arg1 = (wxWindow *) 0 ;
33429 bool arg2 ;
33430 void *argp1 = 0 ;
33431 int res1 = 0 ;
33432 bool val2 ;
33433 int ecode2 = 0 ;
33434 PyObject * obj0 = 0 ;
33435 PyObject * obj1 = 0 ;
33436 char * kwnames[] = {
33437 (char *) "self",(char *) "on", NULL
33438 };
33439
33440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33442 if (!SWIG_IsOK(res1)) {
33443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33444 }
33445 arg1 = reinterpret_cast< wxWindow * >(argp1);
33446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33447 if (!SWIG_IsOK(ecode2)) {
33448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33449 }
33450 arg2 = static_cast< bool >(val2);
33451 {
33452 PyThreadState* __tstate = wxPyBeginAllowThreads();
33453 (arg1)->SetDoubleBuffered(arg2);
33454 wxPyEndAllowThreads(__tstate);
33455 if (PyErr_Occurred()) SWIG_fail;
33456 }
33457 resultobj = SWIG_Py_Void();
33458 return resultobj;
33459 fail:
33460 return NULL;
33461 }
33462
33463
33464 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33465 PyObject *resultobj = 0;
33466 wxWindow *arg1 = (wxWindow *) 0 ;
33467 long arg2 ;
33468 wxWindow *result = 0 ;
33469 void *argp1 = 0 ;
33470 int res1 = 0 ;
33471 long val2 ;
33472 int ecode2 = 0 ;
33473 PyObject * obj0 = 0 ;
33474 PyObject * obj1 = 0 ;
33475 char * kwnames[] = {
33476 (char *) "self",(char *) "winid", NULL
33477 };
33478
33479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33481 if (!SWIG_IsOK(res1)) {
33482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33483 }
33484 arg1 = reinterpret_cast< wxWindow * >(argp1);
33485 ecode2 = SWIG_AsVal_long(obj1, &val2);
33486 if (!SWIG_IsOK(ecode2)) {
33487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33488 }
33489 arg2 = static_cast< long >(val2);
33490 {
33491 PyThreadState* __tstate = wxPyBeginAllowThreads();
33492 result = (wxWindow *)(arg1)->FindWindow(arg2);
33493 wxPyEndAllowThreads(__tstate);
33494 if (PyErr_Occurred()) SWIG_fail;
33495 }
33496 {
33497 resultobj = wxPyMake_wxObject(result, 0);
33498 }
33499 return resultobj;
33500 fail:
33501 return NULL;
33502 }
33503
33504
33505 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33506 PyObject *resultobj = 0;
33507 wxWindow *arg1 = (wxWindow *) 0 ;
33508 wxString *arg2 = 0 ;
33509 wxWindow *result = 0 ;
33510 void *argp1 = 0 ;
33511 int res1 = 0 ;
33512 bool temp2 = false ;
33513 PyObject * obj0 = 0 ;
33514 PyObject * obj1 = 0 ;
33515 char * kwnames[] = {
33516 (char *) "self",(char *) "name", NULL
33517 };
33518
33519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33521 if (!SWIG_IsOK(res1)) {
33522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33523 }
33524 arg1 = reinterpret_cast< wxWindow * >(argp1);
33525 {
33526 arg2 = wxString_in_helper(obj1);
33527 if (arg2 == NULL) SWIG_fail;
33528 temp2 = true;
33529 }
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 {
33537 resultobj = wxPyMake_wxObject(result, 0);
33538 }
33539 {
33540 if (temp2)
33541 delete arg2;
33542 }
33543 return resultobj;
33544 fail:
33545 {
33546 if (temp2)
33547 delete arg2;
33548 }
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 wxEvtHandler *result = 0 ;
33557 void *argp1 = 0 ;
33558 int res1 = 0 ;
33559 PyObject *swig_obj[1] ;
33560
33561 if (!args) SWIG_fail;
33562 swig_obj[0] = args;
33563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33566 }
33567 arg1 = reinterpret_cast< wxWindow * >(argp1);
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 resultobj = wxPyMake_wxObject(result, 0);
33576 }
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33584 PyObject *resultobj = 0;
33585 wxWindow *arg1 = (wxWindow *) 0 ;
33586 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 void *argp2 = 0 ;
33590 int res2 = 0 ;
33591 PyObject * obj0 = 0 ;
33592 PyObject * obj1 = 0 ;
33593 char * kwnames[] = {
33594 (char *) "self",(char *) "handler", NULL
33595 };
33596
33597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33599 if (!SWIG_IsOK(res1)) {
33600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33601 }
33602 arg1 = reinterpret_cast< wxWindow * >(argp1);
33603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33604 if (!SWIG_IsOK(res2)) {
33605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33606 }
33607 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 (arg1)->SetEventHandler(arg2);
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 resultobj = SWIG_Py_Void();
33615 return resultobj;
33616 fail:
33617 return NULL;
33618 }
33619
33620
33621 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33622 PyObject *resultobj = 0;
33623 wxWindow *arg1 = (wxWindow *) 0 ;
33624 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33625 void *argp1 = 0 ;
33626 int res1 = 0 ;
33627 void *argp2 = 0 ;
33628 int res2 = 0 ;
33629 PyObject * obj0 = 0 ;
33630 PyObject * obj1 = 0 ;
33631 char * kwnames[] = {
33632 (char *) "self",(char *) "handler", NULL
33633 };
33634
33635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33637 if (!SWIG_IsOK(res1)) {
33638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33639 }
33640 arg1 = reinterpret_cast< wxWindow * >(argp1);
33641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33642 if (!SWIG_IsOK(res2)) {
33643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33644 }
33645 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33646 {
33647 PyThreadState* __tstate = wxPyBeginAllowThreads();
33648 (arg1)->PushEventHandler(arg2);
33649 wxPyEndAllowThreads(__tstate);
33650 if (PyErr_Occurred()) SWIG_fail;
33651 }
33652 resultobj = SWIG_Py_Void();
33653 return resultobj;
33654 fail:
33655 return NULL;
33656 }
33657
33658
33659 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33660 PyObject *resultobj = 0;
33661 wxWindow *arg1 = (wxWindow *) 0 ;
33662 bool arg2 = (bool) false ;
33663 wxEvtHandler *result = 0 ;
33664 void *argp1 = 0 ;
33665 int res1 = 0 ;
33666 bool val2 ;
33667 int ecode2 = 0 ;
33668 PyObject * obj0 = 0 ;
33669 PyObject * obj1 = 0 ;
33670 char * kwnames[] = {
33671 (char *) "self",(char *) "deleteHandler", NULL
33672 };
33673
33674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33676 if (!SWIG_IsOK(res1)) {
33677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33678 }
33679 arg1 = reinterpret_cast< wxWindow * >(argp1);
33680 if (obj1) {
33681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33682 if (!SWIG_IsOK(ecode2)) {
33683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33684 }
33685 arg2 = static_cast< bool >(val2);
33686 }
33687 {
33688 PyThreadState* __tstate = wxPyBeginAllowThreads();
33689 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33690 wxPyEndAllowThreads(__tstate);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 }
33693 {
33694 resultobj = wxPyMake_wxObject(result, 0);
33695 }
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33706 bool result;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 void *argp2 = 0 ;
33710 int res2 = 0 ;
33711 PyObject * obj0 = 0 ;
33712 PyObject * obj1 = 0 ;
33713 char * kwnames[] = {
33714 (char *) "self",(char *) "handler", NULL
33715 };
33716
33717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33719 if (!SWIG_IsOK(res1)) {
33720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33721 }
33722 arg1 = reinterpret_cast< wxWindow * >(argp1);
33723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33724 if (!SWIG_IsOK(res2)) {
33725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33726 }
33727 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33728 {
33729 PyThreadState* __tstate = wxPyBeginAllowThreads();
33730 result = (bool)(arg1)->RemoveEventHandler(arg2);
33731 wxPyEndAllowThreads(__tstate);
33732 if (PyErr_Occurred()) SWIG_fail;
33733 }
33734 {
33735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33736 }
33737 return resultobj;
33738 fail:
33739 return NULL;
33740 }
33741
33742
33743 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33744 PyObject *resultobj = 0;
33745 wxWindow *arg1 = (wxWindow *) 0 ;
33746 wxValidator *arg2 = 0 ;
33747 void *argp1 = 0 ;
33748 int res1 = 0 ;
33749 void *argp2 = 0 ;
33750 int res2 = 0 ;
33751 PyObject * obj0 = 0 ;
33752 PyObject * obj1 = 0 ;
33753 char * kwnames[] = {
33754 (char *) "self",(char *) "validator", NULL
33755 };
33756
33757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33759 if (!SWIG_IsOK(res1)) {
33760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33761 }
33762 arg1 = reinterpret_cast< wxWindow * >(argp1);
33763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33764 if (!SWIG_IsOK(res2)) {
33765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33766 }
33767 if (!argp2) {
33768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33769 }
33770 arg2 = reinterpret_cast< wxValidator * >(argp2);
33771 {
33772 PyThreadState* __tstate = wxPyBeginAllowThreads();
33773 (arg1)->SetValidator((wxValidator const &)*arg2);
33774 wxPyEndAllowThreads(__tstate);
33775 if (PyErr_Occurred()) SWIG_fail;
33776 }
33777 resultobj = SWIG_Py_Void();
33778 return resultobj;
33779 fail:
33780 return NULL;
33781 }
33782
33783
33784 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33785 PyObject *resultobj = 0;
33786 wxWindow *arg1 = (wxWindow *) 0 ;
33787 wxValidator *result = 0 ;
33788 void *argp1 = 0 ;
33789 int res1 = 0 ;
33790 PyObject *swig_obj[1] ;
33791
33792 if (!args) SWIG_fail;
33793 swig_obj[0] = args;
33794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33795 if (!SWIG_IsOK(res1)) {
33796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33797 }
33798 arg1 = reinterpret_cast< wxWindow * >(argp1);
33799 {
33800 PyThreadState* __tstate = wxPyBeginAllowThreads();
33801 result = (wxValidator *)(arg1)->GetValidator();
33802 wxPyEndAllowThreads(__tstate);
33803 if (PyErr_Occurred()) SWIG_fail;
33804 }
33805 {
33806 resultobj = wxPyMake_wxObject(result, (bool)0);
33807 }
33808 return resultobj;
33809 fail:
33810 return NULL;
33811 }
33812
33813
33814 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33815 PyObject *resultobj = 0;
33816 wxWindow *arg1 = (wxWindow *) 0 ;
33817 bool result;
33818 void *argp1 = 0 ;
33819 int res1 = 0 ;
33820 PyObject *swig_obj[1] ;
33821
33822 if (!args) SWIG_fail;
33823 swig_obj[0] = args;
33824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33825 if (!SWIG_IsOK(res1)) {
33826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33827 }
33828 arg1 = reinterpret_cast< wxWindow * >(argp1);
33829 {
33830 PyThreadState* __tstate = wxPyBeginAllowThreads();
33831 result = (bool)(arg1)->Validate();
33832 wxPyEndAllowThreads(__tstate);
33833 if (PyErr_Occurred()) SWIG_fail;
33834 }
33835 {
33836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33837 }
33838 return resultobj;
33839 fail:
33840 return NULL;
33841 }
33842
33843
33844 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33845 PyObject *resultobj = 0;
33846 wxWindow *arg1 = (wxWindow *) 0 ;
33847 bool result;
33848 void *argp1 = 0 ;
33849 int res1 = 0 ;
33850 PyObject *swig_obj[1] ;
33851
33852 if (!args) SWIG_fail;
33853 swig_obj[0] = args;
33854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33855 if (!SWIG_IsOK(res1)) {
33856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33857 }
33858 arg1 = reinterpret_cast< wxWindow * >(argp1);
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (bool)(arg1)->TransferDataToWindow();
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 {
33866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33867 }
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33875 PyObject *resultobj = 0;
33876 wxWindow *arg1 = (wxWindow *) 0 ;
33877 bool result;
33878 void *argp1 = 0 ;
33879 int res1 = 0 ;
33880 PyObject *swig_obj[1] ;
33881
33882 if (!args) SWIG_fail;
33883 swig_obj[0] = args;
33884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33885 if (!SWIG_IsOK(res1)) {
33886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33887 }
33888 arg1 = reinterpret_cast< wxWindow * >(argp1);
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = (bool)(arg1)->TransferDataFromWindow();
33892 wxPyEndAllowThreads(__tstate);
33893 if (PyErr_Occurred()) SWIG_fail;
33894 }
33895 {
33896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33897 }
33898 return resultobj;
33899 fail:
33900 return NULL;
33901 }
33902
33903
33904 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33905 PyObject *resultobj = 0;
33906 wxWindow *arg1 = (wxWindow *) 0 ;
33907 void *argp1 = 0 ;
33908 int res1 = 0 ;
33909 PyObject *swig_obj[1] ;
33910
33911 if (!args) SWIG_fail;
33912 swig_obj[0] = args;
33913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33916 }
33917 arg1 = reinterpret_cast< wxWindow * >(argp1);
33918 {
33919 PyThreadState* __tstate = wxPyBeginAllowThreads();
33920 (arg1)->InitDialog();
33921 wxPyEndAllowThreads(__tstate);
33922 if (PyErr_Occurred()) SWIG_fail;
33923 }
33924 resultobj = SWIG_Py_Void();
33925 return resultobj;
33926 fail:
33927 return NULL;
33928 }
33929
33930
33931 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33932 PyObject *resultobj = 0;
33933 wxWindow *arg1 = (wxWindow *) 0 ;
33934 wxAcceleratorTable *arg2 = 0 ;
33935 void *argp1 = 0 ;
33936 int res1 = 0 ;
33937 void *argp2 = 0 ;
33938 int res2 = 0 ;
33939 PyObject * obj0 = 0 ;
33940 PyObject * obj1 = 0 ;
33941 char * kwnames[] = {
33942 (char *) "self",(char *) "accel", NULL
33943 };
33944
33945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33949 }
33950 arg1 = reinterpret_cast< wxWindow * >(argp1);
33951 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33952 if (!SWIG_IsOK(res2)) {
33953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33954 }
33955 if (!argp2) {
33956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33957 }
33958 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33962 wxPyEndAllowThreads(__tstate);
33963 if (PyErr_Occurred()) SWIG_fail;
33964 }
33965 resultobj = SWIG_Py_Void();
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33973 PyObject *resultobj = 0;
33974 wxWindow *arg1 = (wxWindow *) 0 ;
33975 wxAcceleratorTable *result = 0 ;
33976 void *argp1 = 0 ;
33977 int res1 = 0 ;
33978 PyObject *swig_obj[1] ;
33979
33980 if (!args) SWIG_fail;
33981 swig_obj[0] = args;
33982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33983 if (!SWIG_IsOK(res1)) {
33984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33985 }
33986 arg1 = reinterpret_cast< wxWindow * >(argp1);
33987 {
33988 PyThreadState* __tstate = wxPyBeginAllowThreads();
33989 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33990 wxPyEndAllowThreads(__tstate);
33991 if (PyErr_Occurred()) SWIG_fail;
33992 }
33993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33994 return resultobj;
33995 fail:
33996 return NULL;
33997 }
33998
33999
34000 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34001 PyObject *resultobj = 0;
34002 wxWindow *arg1 = (wxWindow *) 0 ;
34003 int arg2 ;
34004 int arg3 ;
34005 int arg4 ;
34006 bool result;
34007 void *argp1 = 0 ;
34008 int res1 = 0 ;
34009 int val2 ;
34010 int ecode2 = 0 ;
34011 int val3 ;
34012 int ecode3 = 0 ;
34013 int val4 ;
34014 int ecode4 = 0 ;
34015 PyObject * obj0 = 0 ;
34016 PyObject * obj1 = 0 ;
34017 PyObject * obj2 = 0 ;
34018 PyObject * obj3 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34027 }
34028 arg1 = reinterpret_cast< wxWindow * >(argp1);
34029 ecode2 = SWIG_AsVal_int(obj1, &val2);
34030 if (!SWIG_IsOK(ecode2)) {
34031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34032 }
34033 arg2 = static_cast< int >(val2);
34034 ecode3 = SWIG_AsVal_int(obj2, &val3);
34035 if (!SWIG_IsOK(ecode3)) {
34036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34037 }
34038 arg3 = static_cast< int >(val3);
34039 ecode4 = SWIG_AsVal_int(obj3, &val4);
34040 if (!SWIG_IsOK(ecode4)) {
34041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34042 }
34043 arg4 = static_cast< int >(val4);
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 {
34051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34052 }
34053 return resultobj;
34054 fail:
34055 return NULL;
34056 }
34057
34058
34059 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34060 PyObject *resultobj = 0;
34061 wxWindow *arg1 = (wxWindow *) 0 ;
34062 int arg2 ;
34063 bool result;
34064 void *argp1 = 0 ;
34065 int res1 = 0 ;
34066 int val2 ;
34067 int ecode2 = 0 ;
34068 PyObject * obj0 = 0 ;
34069 PyObject * obj1 = 0 ;
34070 char * kwnames[] = {
34071 (char *) "self",(char *) "hotkeyId", NULL
34072 };
34073
34074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34078 }
34079 arg1 = reinterpret_cast< wxWindow * >(argp1);
34080 ecode2 = SWIG_AsVal_int(obj1, &val2);
34081 if (!SWIG_IsOK(ecode2)) {
34082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34083 }
34084 arg2 = static_cast< int >(val2);
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34088 wxPyEndAllowThreads(__tstate);
34089 if (PyErr_Occurred()) SWIG_fail;
34090 }
34091 {
34092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34093 }
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34101 PyObject *resultobj = 0;
34102 wxWindow *arg1 = (wxWindow *) 0 ;
34103 wxPoint *arg2 = 0 ;
34104 wxPoint result;
34105 void *argp1 = 0 ;
34106 int res1 = 0 ;
34107 wxPoint temp2 ;
34108 PyObject * obj0 = 0 ;
34109 PyObject * obj1 = 0 ;
34110 char * kwnames[] = {
34111 (char *) "self",(char *) "pt", NULL
34112 };
34113
34114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 {
34121 arg2 = &temp2;
34122 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34123 }
34124 {
34125 PyThreadState* __tstate = wxPyBeginAllowThreads();
34126 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34127 wxPyEndAllowThreads(__tstate);
34128 if (PyErr_Occurred()) SWIG_fail;
34129 }
34130 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34131 return resultobj;
34132 fail:
34133 return NULL;
34134 }
34135
34136
34137 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34138 PyObject *resultobj = 0;
34139 wxWindow *arg1 = (wxWindow *) 0 ;
34140 wxSize *arg2 = 0 ;
34141 wxSize result;
34142 void *argp1 = 0 ;
34143 int res1 = 0 ;
34144 wxSize temp2 ;
34145 PyObject * obj0 = 0 ;
34146 PyObject * obj1 = 0 ;
34147 char * kwnames[] = {
34148 (char *) "self",(char *) "sz", NULL
34149 };
34150
34151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34153 if (!SWIG_IsOK(res1)) {
34154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34155 }
34156 arg1 = reinterpret_cast< wxWindow * >(argp1);
34157 {
34158 arg2 = &temp2;
34159 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34160 }
34161 {
34162 PyThreadState* __tstate = wxPyBeginAllowThreads();
34163 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34164 wxPyEndAllowThreads(__tstate);
34165 if (PyErr_Occurred()) SWIG_fail;
34166 }
34167 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34175 PyObject *resultobj = 0;
34176 wxWindow *arg1 = (wxWindow *) 0 ;
34177 wxPoint *arg2 = 0 ;
34178 wxPoint result;
34179 void *argp1 = 0 ;
34180 int res1 = 0 ;
34181 wxPoint temp2 ;
34182 PyObject * obj0 = 0 ;
34183 PyObject * obj1 = 0 ;
34184 char * kwnames[] = {
34185 (char *) "self",(char *) "pt", NULL
34186 };
34187
34188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34190 if (!SWIG_IsOK(res1)) {
34191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34192 }
34193 arg1 = reinterpret_cast< wxWindow * >(argp1);
34194 {
34195 arg2 = &temp2;
34196 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34197 }
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34201 wxPyEndAllowThreads(__tstate);
34202 if (PyErr_Occurred()) SWIG_fail;
34203 }
34204 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 wxSize *arg2 = 0 ;
34215 wxSize result;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 wxSize temp2 ;
34219 PyObject * obj0 = 0 ;
34220 PyObject * obj1 = 0 ;
34221 char * kwnames[] = {
34222 (char *) "self",(char *) "sz", NULL
34223 };
34224
34225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34227 if (!SWIG_IsOK(res1)) {
34228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34229 }
34230 arg1 = reinterpret_cast< wxWindow * >(argp1);
34231 {
34232 arg2 = &temp2;
34233 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34234 }
34235 {
34236 PyThreadState* __tstate = wxPyBeginAllowThreads();
34237 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34238 wxPyEndAllowThreads(__tstate);
34239 if (PyErr_Occurred()) SWIG_fail;
34240 }
34241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34242 return resultobj;
34243 fail:
34244 return NULL;
34245 }
34246
34247
34248 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34249 PyObject *resultobj = 0;
34250 wxWindow *arg1 = (wxWindow *) 0 ;
34251 wxPoint *arg2 = 0 ;
34252 wxPoint result;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 wxPoint temp2 ;
34256 PyObject * obj0 = 0 ;
34257 PyObject * obj1 = 0 ;
34258 char * kwnames[] = {
34259 (char *) "self",(char *) "pt", NULL
34260 };
34261
34262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34266 }
34267 arg1 = reinterpret_cast< wxWindow * >(argp1);
34268 {
34269 arg2 = &temp2;
34270 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34271 }
34272 {
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34275 wxPyEndAllowThreads(__tstate);
34276 if (PyErr_Occurred()) SWIG_fail;
34277 }
34278 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34279 return resultobj;
34280 fail:
34281 return NULL;
34282 }
34283
34284
34285 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34286 PyObject *resultobj = 0;
34287 wxWindow *arg1 = (wxWindow *) 0 ;
34288 wxSize *arg2 = 0 ;
34289 wxSize result;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 wxSize temp2 ;
34293 PyObject * obj0 = 0 ;
34294 PyObject * obj1 = 0 ;
34295 char * kwnames[] = {
34296 (char *) "self",(char *) "sz", NULL
34297 };
34298
34299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34301 if (!SWIG_IsOK(res1)) {
34302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34303 }
34304 arg1 = reinterpret_cast< wxWindow * >(argp1);
34305 {
34306 arg2 = &temp2;
34307 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34308 }
34309 {
34310 PyThreadState* __tstate = wxPyBeginAllowThreads();
34311 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34312 wxPyEndAllowThreads(__tstate);
34313 if (PyErr_Occurred()) SWIG_fail;
34314 }
34315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34316 return resultobj;
34317 fail:
34318 return NULL;
34319 }
34320
34321
34322 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34323 PyObject *resultobj = 0;
34324 wxWindow *arg1 = (wxWindow *) 0 ;
34325 int arg2 ;
34326 int arg3 ;
34327 void *argp1 = 0 ;
34328 int res1 = 0 ;
34329 int val2 ;
34330 int ecode2 = 0 ;
34331 int val3 ;
34332 int ecode3 = 0 ;
34333 PyObject * obj0 = 0 ;
34334 PyObject * obj1 = 0 ;
34335 PyObject * obj2 = 0 ;
34336 char * kwnames[] = {
34337 (char *) "self",(char *) "x",(char *) "y", NULL
34338 };
34339
34340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 ecode2 = SWIG_AsVal_int(obj1, &val2);
34347 if (!SWIG_IsOK(ecode2)) {
34348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34349 }
34350 arg2 = static_cast< int >(val2);
34351 ecode3 = SWIG_AsVal_int(obj2, &val3);
34352 if (!SWIG_IsOK(ecode3)) {
34353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34354 }
34355 arg3 = static_cast< int >(val3);
34356 {
34357 PyThreadState* __tstate = wxPyBeginAllowThreads();
34358 (arg1)->WarpPointer(arg2,arg3);
34359 wxPyEndAllowThreads(__tstate);
34360 if (PyErr_Occurred()) SWIG_fail;
34361 }
34362 resultobj = SWIG_Py_Void();
34363 return resultobj;
34364 fail:
34365 return NULL;
34366 }
34367
34368
34369 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34370 PyObject *resultobj = 0;
34371 wxWindow *arg1 = (wxWindow *) 0 ;
34372 void *argp1 = 0 ;
34373 int res1 = 0 ;
34374 PyObject *swig_obj[1] ;
34375
34376 if (!args) SWIG_fail;
34377 swig_obj[0] = args;
34378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34379 if (!SWIG_IsOK(res1)) {
34380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34381 }
34382 arg1 = reinterpret_cast< wxWindow * >(argp1);
34383 {
34384 PyThreadState* __tstate = wxPyBeginAllowThreads();
34385 (arg1)->CaptureMouse();
34386 wxPyEndAllowThreads(__tstate);
34387 if (PyErr_Occurred()) SWIG_fail;
34388 }
34389 resultobj = SWIG_Py_Void();
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34397 PyObject *resultobj = 0;
34398 wxWindow *arg1 = (wxWindow *) 0 ;
34399 void *argp1 = 0 ;
34400 int res1 = 0 ;
34401 PyObject *swig_obj[1] ;
34402
34403 if (!args) SWIG_fail;
34404 swig_obj[0] = args;
34405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34406 if (!SWIG_IsOK(res1)) {
34407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34408 }
34409 arg1 = reinterpret_cast< wxWindow * >(argp1);
34410 {
34411 PyThreadState* __tstate = wxPyBeginAllowThreads();
34412 (arg1)->ReleaseMouse();
34413 wxPyEndAllowThreads(__tstate);
34414 if (PyErr_Occurred()) SWIG_fail;
34415 }
34416 resultobj = SWIG_Py_Void();
34417 return resultobj;
34418 fail:
34419 return NULL;
34420 }
34421
34422
34423 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34424 PyObject *resultobj = 0;
34425 wxWindow *result = 0 ;
34426
34427 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34428 {
34429 if (!wxPyCheckForApp()) SWIG_fail;
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = (wxWindow *)wxWindow::GetCapture();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 {
34436 resultobj = wxPyMake_wxObject(result, 0);
34437 }
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34445 PyObject *resultobj = 0;
34446 wxWindow *arg1 = (wxWindow *) 0 ;
34447 bool result;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 PyObject *swig_obj[1] ;
34451
34452 if (!args) SWIG_fail;
34453 swig_obj[0] = args;
34454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34457 }
34458 arg1 = reinterpret_cast< wxWindow * >(argp1);
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 result = (bool)((wxWindow const *)arg1)->HasCapture();
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 {
34466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34467 }
34468 return resultobj;
34469 fail:
34470 return NULL;
34471 }
34472
34473
34474 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34475 PyObject *resultobj = 0;
34476 wxWindow *arg1 = (wxWindow *) 0 ;
34477 bool arg2 = (bool) true ;
34478 wxRect *arg3 = (wxRect *) NULL ;
34479 void *argp1 = 0 ;
34480 int res1 = 0 ;
34481 bool val2 ;
34482 int ecode2 = 0 ;
34483 void *argp3 = 0 ;
34484 int res3 = 0 ;
34485 PyObject * obj0 = 0 ;
34486 PyObject * obj1 = 0 ;
34487 PyObject * obj2 = 0 ;
34488 char * kwnames[] = {
34489 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34490 };
34491
34492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34496 }
34497 arg1 = reinterpret_cast< wxWindow * >(argp1);
34498 if (obj1) {
34499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34500 if (!SWIG_IsOK(ecode2)) {
34501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34502 }
34503 arg2 = static_cast< bool >(val2);
34504 }
34505 if (obj2) {
34506 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34507 if (!SWIG_IsOK(res3)) {
34508 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34509 }
34510 arg3 = reinterpret_cast< wxRect * >(argp3);
34511 }
34512 {
34513 PyThreadState* __tstate = wxPyBeginAllowThreads();
34514 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34515 wxPyEndAllowThreads(__tstate);
34516 if (PyErr_Occurred()) SWIG_fail;
34517 }
34518 resultobj = SWIG_Py_Void();
34519 return resultobj;
34520 fail:
34521 return NULL;
34522 }
34523
34524
34525 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34526 PyObject *resultobj = 0;
34527 wxWindow *arg1 = (wxWindow *) 0 ;
34528 wxRect *arg2 = 0 ;
34529 bool arg3 = (bool) true ;
34530 void *argp1 = 0 ;
34531 int res1 = 0 ;
34532 wxRect temp2 ;
34533 bool val3 ;
34534 int ecode3 = 0 ;
34535 PyObject * obj0 = 0 ;
34536 PyObject * obj1 = 0 ;
34537 PyObject * obj2 = 0 ;
34538 char * kwnames[] = {
34539 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34540 };
34541
34542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34544 if (!SWIG_IsOK(res1)) {
34545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34546 }
34547 arg1 = reinterpret_cast< wxWindow * >(argp1);
34548 {
34549 arg2 = &temp2;
34550 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34551 }
34552 if (obj2) {
34553 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34554 if (!SWIG_IsOK(ecode3)) {
34555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34556 }
34557 arg3 = static_cast< bool >(val3);
34558 }
34559 {
34560 PyThreadState* __tstate = wxPyBeginAllowThreads();
34561 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 resultobj = SWIG_Py_Void();
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34573 PyObject *resultobj = 0;
34574 wxWindow *arg1 = (wxWindow *) 0 ;
34575 void *argp1 = 0 ;
34576 int res1 = 0 ;
34577 PyObject *swig_obj[1] ;
34578
34579 if (!args) SWIG_fail;
34580 swig_obj[0] = args;
34581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34582 if (!SWIG_IsOK(res1)) {
34583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34584 }
34585 arg1 = reinterpret_cast< wxWindow * >(argp1);
34586 {
34587 PyThreadState* __tstate = wxPyBeginAllowThreads();
34588 (arg1)->Update();
34589 wxPyEndAllowThreads(__tstate);
34590 if (PyErr_Occurred()) SWIG_fail;
34591 }
34592 resultobj = SWIG_Py_Void();
34593 return resultobj;
34594 fail:
34595 return NULL;
34596 }
34597
34598
34599 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34600 PyObject *resultobj = 0;
34601 wxWindow *arg1 = (wxWindow *) 0 ;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 PyObject *swig_obj[1] ;
34605
34606 if (!args) SWIG_fail;
34607 swig_obj[0] = args;
34608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34611 }
34612 arg1 = reinterpret_cast< wxWindow * >(argp1);
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 (arg1)->ClearBackground();
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 resultobj = SWIG_Py_Void();
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34627 PyObject *resultobj = 0;
34628 wxWindow *arg1 = (wxWindow *) 0 ;
34629 void *argp1 = 0 ;
34630 int res1 = 0 ;
34631 PyObject *swig_obj[1] ;
34632
34633 if (!args) SWIG_fail;
34634 swig_obj[0] = args;
34635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34636 if (!SWIG_IsOK(res1)) {
34637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34638 }
34639 arg1 = reinterpret_cast< wxWindow * >(argp1);
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 (arg1)->Freeze();
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_Py_Void();
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 PyObject *swig_obj[1] ;
34659
34660 if (!args) SWIG_fail;
34661 swig_obj[0] = args;
34662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34663 if (!SWIG_IsOK(res1)) {
34664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34665 }
34666 arg1 = reinterpret_cast< wxWindow * >(argp1);
34667 {
34668 PyThreadState* __tstate = wxPyBeginAllowThreads();
34669 (arg1)->Thaw();
34670 wxPyEndAllowThreads(__tstate);
34671 if (PyErr_Occurred()) SWIG_fail;
34672 }
34673 resultobj = SWIG_Py_Void();
34674 return resultobj;
34675 fail:
34676 return NULL;
34677 }
34678
34679
34680 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34681 PyObject *resultobj = 0;
34682 wxWindow *arg1 = (wxWindow *) 0 ;
34683 wxDC *arg2 = 0 ;
34684 void *argp1 = 0 ;
34685 int res1 = 0 ;
34686 void *argp2 = 0 ;
34687 int res2 = 0 ;
34688 PyObject * obj0 = 0 ;
34689 PyObject * obj1 = 0 ;
34690 char * kwnames[] = {
34691 (char *) "self",(char *) "dc", NULL
34692 };
34693
34694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34696 if (!SWIG_IsOK(res1)) {
34697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34698 }
34699 arg1 = reinterpret_cast< wxWindow * >(argp1);
34700 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34701 if (!SWIG_IsOK(res2)) {
34702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34703 }
34704 if (!argp2) {
34705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34706 }
34707 arg2 = reinterpret_cast< wxDC * >(argp2);
34708 {
34709 PyThreadState* __tstate = wxPyBeginAllowThreads();
34710 (arg1)->PrepareDC(*arg2);
34711 wxPyEndAllowThreads(__tstate);
34712 if (PyErr_Occurred()) SWIG_fail;
34713 }
34714 resultobj = SWIG_Py_Void();
34715 return resultobj;
34716 fail:
34717 return NULL;
34718 }
34719
34720
34721 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34722 PyObject *resultobj = 0;
34723 wxWindow *arg1 = (wxWindow *) 0 ;
34724 wxRegion *result = 0 ;
34725 void *argp1 = 0 ;
34726 int res1 = 0 ;
34727 PyObject *swig_obj[1] ;
34728
34729 if (!args) SWIG_fail;
34730 swig_obj[0] = args;
34731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34732 if (!SWIG_IsOK(res1)) {
34733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34734 }
34735 arg1 = reinterpret_cast< wxWindow * >(argp1);
34736 {
34737 PyThreadState* __tstate = wxPyBeginAllowThreads();
34738 {
34739 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34740 result = (wxRegion *) &_result_ref;
34741 }
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34753 PyObject *resultobj = 0;
34754 wxWindow *arg1 = (wxWindow *) 0 ;
34755 wxRect result;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 PyObject *swig_obj[1] ;
34759
34760 if (!args) SWIG_fail;
34761 swig_obj[0] = args;
34762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34765 }
34766 arg1 = reinterpret_cast< wxWindow * >(argp1);
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34781 PyObject *resultobj = 0;
34782 wxWindow *arg1 = (wxWindow *) 0 ;
34783 int arg2 ;
34784 int arg3 ;
34785 int arg4 = (int) 1 ;
34786 int arg5 = (int) 1 ;
34787 bool result;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 int val2 ;
34791 int ecode2 = 0 ;
34792 int val3 ;
34793 int ecode3 = 0 ;
34794 int val4 ;
34795 int ecode4 = 0 ;
34796 int val5 ;
34797 int ecode5 = 0 ;
34798 PyObject * obj0 = 0 ;
34799 PyObject * obj1 = 0 ;
34800 PyObject * obj2 = 0 ;
34801 PyObject * obj3 = 0 ;
34802 PyObject * obj4 = 0 ;
34803 char * kwnames[] = {
34804 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34805 };
34806
34807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34809 if (!SWIG_IsOK(res1)) {
34810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34811 }
34812 arg1 = reinterpret_cast< wxWindow * >(argp1);
34813 ecode2 = SWIG_AsVal_int(obj1, &val2);
34814 if (!SWIG_IsOK(ecode2)) {
34815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34816 }
34817 arg2 = static_cast< int >(val2);
34818 ecode3 = SWIG_AsVal_int(obj2, &val3);
34819 if (!SWIG_IsOK(ecode3)) {
34820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34821 }
34822 arg3 = static_cast< int >(val3);
34823 if (obj3) {
34824 ecode4 = SWIG_AsVal_int(obj3, &val4);
34825 if (!SWIG_IsOK(ecode4)) {
34826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34827 }
34828 arg4 = static_cast< int >(val4);
34829 }
34830 if (obj4) {
34831 ecode5 = SWIG_AsVal_int(obj4, &val5);
34832 if (!SWIG_IsOK(ecode5)) {
34833 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34834 }
34835 arg5 = static_cast< int >(val5);
34836 }
34837 {
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 {
34844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34845 }
34846 return resultobj;
34847 fail:
34848 return NULL;
34849 }
34850
34851
34852 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34853 PyObject *resultobj = 0;
34854 wxWindow *arg1 = (wxWindow *) 0 ;
34855 wxPoint *arg2 = 0 ;
34856 bool result;
34857 void *argp1 = 0 ;
34858 int res1 = 0 ;
34859 wxPoint temp2 ;
34860 PyObject * obj0 = 0 ;
34861 PyObject * obj1 = 0 ;
34862 char * kwnames[] = {
34863 (char *) "self",(char *) "pt", NULL
34864 };
34865
34866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34868 if (!SWIG_IsOK(res1)) {
34869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34870 }
34871 arg1 = reinterpret_cast< wxWindow * >(argp1);
34872 {
34873 arg2 = &temp2;
34874 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34875 }
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj = 0;
34893 wxWindow *arg1 = (wxWindow *) 0 ;
34894 wxRect *arg2 = 0 ;
34895 bool result;
34896 void *argp1 = 0 ;
34897 int res1 = 0 ;
34898 wxRect temp2 ;
34899 PyObject * obj0 = 0 ;
34900 PyObject * obj1 = 0 ;
34901 char * kwnames[] = {
34902 (char *) "self",(char *) "rect", NULL
34903 };
34904
34905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34907 if (!SWIG_IsOK(res1)) {
34908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34909 }
34910 arg1 = reinterpret_cast< wxWindow * >(argp1);
34911 {
34912 arg2 = &temp2;
34913 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34914 }
34915 {
34916 PyThreadState* __tstate = wxPyBeginAllowThreads();
34917 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 {
34922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34923 }
34924 return resultobj;
34925 fail:
34926 return NULL;
34927 }
34928
34929
34930 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34931 PyObject *resultobj = 0;
34932 wxWindow *arg1 = (wxWindow *) 0 ;
34933 SwigValueWrapper<wxVisualAttributes > result;
34934 void *argp1 = 0 ;
34935 int res1 = 0 ;
34936 PyObject *swig_obj[1] ;
34937
34938 if (!args) SWIG_fail;
34939 swig_obj[0] = args;
34940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34941 if (!SWIG_IsOK(res1)) {
34942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34943 }
34944 arg1 = reinterpret_cast< wxWindow * >(argp1);
34945 {
34946 PyThreadState* __tstate = wxPyBeginAllowThreads();
34947 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34952 return resultobj;
34953 fail:
34954 return NULL;
34955 }
34956
34957
34958 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34959 PyObject *resultobj = 0;
34960 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34961 SwigValueWrapper<wxVisualAttributes > result;
34962 int val1 ;
34963 int ecode1 = 0 ;
34964 PyObject * obj0 = 0 ;
34965 char * kwnames[] = {
34966 (char *) "variant", NULL
34967 };
34968
34969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34970 if (obj0) {
34971 ecode1 = SWIG_AsVal_int(obj0, &val1);
34972 if (!SWIG_IsOK(ecode1)) {
34973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34974 }
34975 arg1 = static_cast< wxWindowVariant >(val1);
34976 }
34977 {
34978 if (!wxPyCheckForApp()) SWIG_fail;
34979 PyThreadState* __tstate = wxPyBeginAllowThreads();
34980 result = wxWindow::GetClassDefaultAttributes(arg1);
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34992 PyObject *resultobj = 0;
34993 wxWindow *arg1 = (wxWindow *) 0 ;
34994 wxColour *arg2 = 0 ;
34995 bool result;
34996 void *argp1 = 0 ;
34997 int res1 = 0 ;
34998 wxColour temp2 ;
34999 PyObject * obj0 = 0 ;
35000 PyObject * obj1 = 0 ;
35001 char * kwnames[] = {
35002 (char *) "self",(char *) "colour", NULL
35003 };
35004
35005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35007 if (!SWIG_IsOK(res1)) {
35008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35009 }
35010 arg1 = reinterpret_cast< wxWindow * >(argp1);
35011 {
35012 arg2 = &temp2;
35013 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35014 }
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 {
35022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35023 }
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35031 PyObject *resultobj = 0;
35032 wxWindow *arg1 = (wxWindow *) 0 ;
35033 wxColour *arg2 = 0 ;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 wxColour temp2 ;
35037 PyObject * obj0 = 0 ;
35038 PyObject * obj1 = 0 ;
35039 char * kwnames[] = {
35040 (char *) "self",(char *) "colour", NULL
35041 };
35042
35043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35045 if (!SWIG_IsOK(res1)) {
35046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35047 }
35048 arg1 = reinterpret_cast< wxWindow * >(argp1);
35049 {
35050 arg2 = &temp2;
35051 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35052 }
35053 {
35054 PyThreadState* __tstate = wxPyBeginAllowThreads();
35055 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35056 wxPyEndAllowThreads(__tstate);
35057 if (PyErr_Occurred()) SWIG_fail;
35058 }
35059 resultobj = SWIG_Py_Void();
35060 return resultobj;
35061 fail:
35062 return NULL;
35063 }
35064
35065
35066 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35067 PyObject *resultobj = 0;
35068 wxWindow *arg1 = (wxWindow *) 0 ;
35069 wxColour *arg2 = 0 ;
35070 bool result;
35071 void *argp1 = 0 ;
35072 int res1 = 0 ;
35073 wxColour temp2 ;
35074 PyObject * obj0 = 0 ;
35075 PyObject * obj1 = 0 ;
35076 char * kwnames[] = {
35077 (char *) "self",(char *) "colour", NULL
35078 };
35079
35080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35082 if (!SWIG_IsOK(res1)) {
35083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35084 }
35085 arg1 = reinterpret_cast< wxWindow * >(argp1);
35086 {
35087 arg2 = &temp2;
35088 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35089 }
35090 {
35091 PyThreadState* __tstate = wxPyBeginAllowThreads();
35092 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 {
35097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35098 }
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35106 PyObject *resultobj = 0;
35107 wxWindow *arg1 = (wxWindow *) 0 ;
35108 wxColour *arg2 = 0 ;
35109 void *argp1 = 0 ;
35110 int res1 = 0 ;
35111 wxColour temp2 ;
35112 PyObject * obj0 = 0 ;
35113 PyObject * obj1 = 0 ;
35114 char * kwnames[] = {
35115 (char *) "self",(char *) "colour", NULL
35116 };
35117
35118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35120 if (!SWIG_IsOK(res1)) {
35121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35122 }
35123 arg1 = reinterpret_cast< wxWindow * >(argp1);
35124 {
35125 arg2 = &temp2;
35126 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35127 }
35128 {
35129 PyThreadState* __tstate = wxPyBeginAllowThreads();
35130 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 resultobj = SWIG_Py_Void();
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35142 PyObject *resultobj = 0;
35143 wxWindow *arg1 = (wxWindow *) 0 ;
35144 wxColour result;
35145 void *argp1 = 0 ;
35146 int res1 = 0 ;
35147 PyObject *swig_obj[1] ;
35148
35149 if (!args) SWIG_fail;
35150 swig_obj[0] = args;
35151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35154 }
35155 arg1 = reinterpret_cast< wxWindow * >(argp1);
35156 {
35157 PyThreadState* __tstate = wxPyBeginAllowThreads();
35158 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35163 return resultobj;
35164 fail:
35165 return NULL;
35166 }
35167
35168
35169 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35170 PyObject *resultobj = 0;
35171 wxWindow *arg1 = (wxWindow *) 0 ;
35172 wxColour result;
35173 void *argp1 = 0 ;
35174 int res1 = 0 ;
35175 PyObject *swig_obj[1] ;
35176
35177 if (!args) SWIG_fail;
35178 swig_obj[0] = args;
35179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35182 }
35183 arg1 = reinterpret_cast< wxWindow * >(argp1);
35184 {
35185 PyThreadState* __tstate = wxPyBeginAllowThreads();
35186 result = ((wxWindow const *)arg1)->GetForegroundColour();
35187 wxPyEndAllowThreads(__tstate);
35188 if (PyErr_Occurred()) SWIG_fail;
35189 }
35190 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35198 PyObject *resultobj = 0;
35199 wxWindow *arg1 = (wxWindow *) 0 ;
35200 bool result;
35201 void *argp1 = 0 ;
35202 int res1 = 0 ;
35203 PyObject *swig_obj[1] ;
35204
35205 if (!args) SWIG_fail;
35206 swig_obj[0] = args;
35207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35210 }
35211 arg1 = reinterpret_cast< wxWindow * >(argp1);
35212 {
35213 PyThreadState* __tstate = wxPyBeginAllowThreads();
35214 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 {
35219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35220 }
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35228 PyObject *resultobj = 0;
35229 wxWindow *arg1 = (wxWindow *) 0 ;
35230 bool result;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 PyObject *swig_obj[1] ;
35234
35235 if (!args) SWIG_fail;
35236 swig_obj[0] = args;
35237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35238 if (!SWIG_IsOK(res1)) {
35239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35240 }
35241 arg1 = reinterpret_cast< wxWindow * >(argp1);
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 {
35249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35250 }
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj = 0;
35259 wxWindow *arg1 = (wxWindow *) 0 ;
35260 wxBackgroundStyle arg2 ;
35261 bool result;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 int val2 ;
35265 int ecode2 = 0 ;
35266 PyObject * obj0 = 0 ;
35267 PyObject * obj1 = 0 ;
35268 char * kwnames[] = {
35269 (char *) "self",(char *) "style", NULL
35270 };
35271
35272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35274 if (!SWIG_IsOK(res1)) {
35275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35276 }
35277 arg1 = reinterpret_cast< wxWindow * >(argp1);
35278 ecode2 = SWIG_AsVal_int(obj1, &val2);
35279 if (!SWIG_IsOK(ecode2)) {
35280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35281 }
35282 arg2 = static_cast< wxBackgroundStyle >(val2);
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 {
35290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 wxBackgroundStyle result;
35302 void *argp1 = 0 ;
35303 int res1 = 0 ;
35304 PyObject *swig_obj[1] ;
35305
35306 if (!args) SWIG_fail;
35307 swig_obj[0] = args;
35308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35309 if (!SWIG_IsOK(res1)) {
35310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35311 }
35312 arg1 = reinterpret_cast< wxWindow * >(argp1);
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35316 wxPyEndAllowThreads(__tstate);
35317 if (PyErr_Occurred()) SWIG_fail;
35318 }
35319 resultobj = SWIG_From_int(static_cast< int >(result));
35320 return resultobj;
35321 fail:
35322 return NULL;
35323 }
35324
35325
35326 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35327 PyObject *resultobj = 0;
35328 wxWindow *arg1 = (wxWindow *) 0 ;
35329 bool result;
35330 void *argp1 = 0 ;
35331 int res1 = 0 ;
35332 PyObject *swig_obj[1] ;
35333
35334 if (!args) SWIG_fail;
35335 swig_obj[0] = args;
35336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35337 if (!SWIG_IsOK(res1)) {
35338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35339 }
35340 arg1 = reinterpret_cast< wxWindow * >(argp1);
35341 {
35342 PyThreadState* __tstate = wxPyBeginAllowThreads();
35343 result = (bool)(arg1)->HasTransparentBackground();
35344 wxPyEndAllowThreads(__tstate);
35345 if (PyErr_Occurred()) SWIG_fail;
35346 }
35347 {
35348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35349 }
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 wxCursor *arg2 = 0 ;
35360 bool result;
35361 void *argp1 = 0 ;
35362 int res1 = 0 ;
35363 void *argp2 = 0 ;
35364 int res2 = 0 ;
35365 PyObject * obj0 = 0 ;
35366 PyObject * obj1 = 0 ;
35367 char * kwnames[] = {
35368 (char *) "self",(char *) "cursor", NULL
35369 };
35370
35371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35373 if (!SWIG_IsOK(res1)) {
35374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35375 }
35376 arg1 = reinterpret_cast< wxWindow * >(argp1);
35377 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35378 if (!SWIG_IsOK(res2)) {
35379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35380 }
35381 if (!argp2) {
35382 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35383 }
35384 arg2 = reinterpret_cast< wxCursor * >(argp2);
35385 {
35386 PyThreadState* __tstate = wxPyBeginAllowThreads();
35387 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 {
35392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35393 }
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35401 PyObject *resultobj = 0;
35402 wxWindow *arg1 = (wxWindow *) 0 ;
35403 wxCursor result;
35404 void *argp1 = 0 ;
35405 int res1 = 0 ;
35406 PyObject *swig_obj[1] ;
35407
35408 if (!args) SWIG_fail;
35409 swig_obj[0] = args;
35410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35411 if (!SWIG_IsOK(res1)) {
35412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35413 }
35414 arg1 = reinterpret_cast< wxWindow * >(argp1);
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 result = (arg1)->GetCursor();
35418 wxPyEndAllowThreads(__tstate);
35419 if (PyErr_Occurred()) SWIG_fail;
35420 }
35421 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35422 return resultobj;
35423 fail:
35424 return NULL;
35425 }
35426
35427
35428 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35429 PyObject *resultobj = 0;
35430 wxWindow *arg1 = (wxWindow *) 0 ;
35431 wxFont *arg2 = 0 ;
35432 bool result;
35433 void *argp1 = 0 ;
35434 int res1 = 0 ;
35435 void *argp2 = 0 ;
35436 int res2 = 0 ;
35437 PyObject * obj0 = 0 ;
35438 PyObject * obj1 = 0 ;
35439 char * kwnames[] = {
35440 (char *) "self",(char *) "font", NULL
35441 };
35442
35443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35445 if (!SWIG_IsOK(res1)) {
35446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35447 }
35448 arg1 = reinterpret_cast< wxWindow * >(argp1);
35449 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35450 if (!SWIG_IsOK(res2)) {
35451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35452 }
35453 if (!argp2) {
35454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35455 }
35456 arg2 = reinterpret_cast< wxFont * >(argp2);
35457 {
35458 PyThreadState* __tstate = wxPyBeginAllowThreads();
35459 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35460 wxPyEndAllowThreads(__tstate);
35461 if (PyErr_Occurred()) SWIG_fail;
35462 }
35463 {
35464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35465 }
35466 return resultobj;
35467 fail:
35468 return NULL;
35469 }
35470
35471
35472 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35473 PyObject *resultobj = 0;
35474 wxWindow *arg1 = (wxWindow *) 0 ;
35475 wxFont *arg2 = 0 ;
35476 void *argp1 = 0 ;
35477 int res1 = 0 ;
35478 void *argp2 = 0 ;
35479 int res2 = 0 ;
35480 PyObject * obj0 = 0 ;
35481 PyObject * obj1 = 0 ;
35482 char * kwnames[] = {
35483 (char *) "self",(char *) "font", NULL
35484 };
35485
35486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35488 if (!SWIG_IsOK(res1)) {
35489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35490 }
35491 arg1 = reinterpret_cast< wxWindow * >(argp1);
35492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35493 if (!SWIG_IsOK(res2)) {
35494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35495 }
35496 if (!argp2) {
35497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35498 }
35499 arg2 = reinterpret_cast< wxFont * >(argp2);
35500 {
35501 PyThreadState* __tstate = wxPyBeginAllowThreads();
35502 (arg1)->SetOwnFont((wxFont const &)*arg2);
35503 wxPyEndAllowThreads(__tstate);
35504 if (PyErr_Occurred()) SWIG_fail;
35505 }
35506 resultobj = SWIG_Py_Void();
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35514 PyObject *resultobj = 0;
35515 wxWindow *arg1 = (wxWindow *) 0 ;
35516 wxFont result;
35517 void *argp1 = 0 ;
35518 int res1 = 0 ;
35519 PyObject *swig_obj[1] ;
35520
35521 if (!args) SWIG_fail;
35522 swig_obj[0] = args;
35523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35524 if (!SWIG_IsOK(res1)) {
35525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35526 }
35527 arg1 = reinterpret_cast< wxWindow * >(argp1);
35528 {
35529 PyThreadState* __tstate = wxPyBeginAllowThreads();
35530 result = (arg1)->GetFont();
35531 wxPyEndAllowThreads(__tstate);
35532 if (PyErr_Occurred()) SWIG_fail;
35533 }
35534 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35535 return resultobj;
35536 fail:
35537 return NULL;
35538 }
35539
35540
35541 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35542 PyObject *resultobj = 0;
35543 wxWindow *arg1 = (wxWindow *) 0 ;
35544 wxCaret *arg2 = (wxCaret *) 0 ;
35545 void *argp1 = 0 ;
35546 int res1 = 0 ;
35547 int res2 = 0 ;
35548 PyObject * obj0 = 0 ;
35549 PyObject * obj1 = 0 ;
35550 char * kwnames[] = {
35551 (char *) "self",(char *) "caret", NULL
35552 };
35553
35554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35556 if (!SWIG_IsOK(res1)) {
35557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35558 }
35559 arg1 = reinterpret_cast< wxWindow * >(argp1);
35560 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35561 if (!SWIG_IsOK(res2)) {
35562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35563 }
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 (arg1)->SetCaret(arg2);
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 resultobj = SWIG_Py_Void();
35571 return resultobj;
35572 fail:
35573 return NULL;
35574 }
35575
35576
35577 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35578 PyObject *resultobj = 0;
35579 wxWindow *arg1 = (wxWindow *) 0 ;
35580 wxCaret *result = 0 ;
35581 void *argp1 = 0 ;
35582 int res1 = 0 ;
35583 PyObject *swig_obj[1] ;
35584
35585 if (!args) SWIG_fail;
35586 swig_obj[0] = args;
35587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35588 if (!SWIG_IsOK(res1)) {
35589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35590 }
35591 arg1 = reinterpret_cast< wxWindow * >(argp1);
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35595 wxPyEndAllowThreads(__tstate);
35596 if (PyErr_Occurred()) SWIG_fail;
35597 }
35598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35606 PyObject *resultobj = 0;
35607 wxWindow *arg1 = (wxWindow *) 0 ;
35608 int result;
35609 void *argp1 = 0 ;
35610 int res1 = 0 ;
35611 PyObject *swig_obj[1] ;
35612
35613 if (!args) SWIG_fail;
35614 swig_obj[0] = args;
35615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35616 if (!SWIG_IsOK(res1)) {
35617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35618 }
35619 arg1 = reinterpret_cast< wxWindow * >(argp1);
35620 {
35621 PyThreadState* __tstate = wxPyBeginAllowThreads();
35622 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35623 wxPyEndAllowThreads(__tstate);
35624 if (PyErr_Occurred()) SWIG_fail;
35625 }
35626 resultobj = SWIG_From_int(static_cast< int >(result));
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35634 PyObject *resultobj = 0;
35635 wxWindow *arg1 = (wxWindow *) 0 ;
35636 int result;
35637 void *argp1 = 0 ;
35638 int res1 = 0 ;
35639 PyObject *swig_obj[1] ;
35640
35641 if (!args) SWIG_fail;
35642 swig_obj[0] = args;
35643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35644 if (!SWIG_IsOK(res1)) {
35645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35646 }
35647 arg1 = reinterpret_cast< wxWindow * >(argp1);
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 resultobj = SWIG_From_int(static_cast< int >(result));
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj = 0;
35663 wxWindow *arg1 = (wxWindow *) 0 ;
35664 wxString *arg2 = 0 ;
35665 int *arg3 = (int *) 0 ;
35666 int *arg4 = (int *) 0 ;
35667 void *argp1 = 0 ;
35668 int res1 = 0 ;
35669 bool temp2 = false ;
35670 int temp3 ;
35671 int res3 = SWIG_TMPOBJ ;
35672 int temp4 ;
35673 int res4 = SWIG_TMPOBJ ;
35674 PyObject * obj0 = 0 ;
35675 PyObject * obj1 = 0 ;
35676 char * kwnames[] = {
35677 (char *) "self",(char *) "string", NULL
35678 };
35679
35680 arg3 = &temp3;
35681 arg4 = &temp4;
35682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35684 if (!SWIG_IsOK(res1)) {
35685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35686 }
35687 arg1 = reinterpret_cast< wxWindow * >(argp1);
35688 {
35689 arg2 = wxString_in_helper(obj1);
35690 if (arg2 == NULL) SWIG_fail;
35691 temp2 = true;
35692 }
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35696 wxPyEndAllowThreads(__tstate);
35697 if (PyErr_Occurred()) SWIG_fail;
35698 }
35699 resultobj = SWIG_Py_Void();
35700 if (SWIG_IsTmpObj(res3)) {
35701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35702 } else {
35703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35705 }
35706 if (SWIG_IsTmpObj(res4)) {
35707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35708 } else {
35709 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35711 }
35712 {
35713 if (temp2)
35714 delete arg2;
35715 }
35716 return resultobj;
35717 fail:
35718 {
35719 if (temp2)
35720 delete arg2;
35721 }
35722 return NULL;
35723 }
35724
35725
35726 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj = 0;
35728 wxWindow *arg1 = (wxWindow *) 0 ;
35729 wxString *arg2 = 0 ;
35730 int *arg3 = (int *) 0 ;
35731 int *arg4 = (int *) 0 ;
35732 int *arg5 = (int *) 0 ;
35733 int *arg6 = (int *) 0 ;
35734 wxFont *arg7 = (wxFont *) NULL ;
35735 void *argp1 = 0 ;
35736 int res1 = 0 ;
35737 bool temp2 = false ;
35738 int temp3 ;
35739 int res3 = SWIG_TMPOBJ ;
35740 int temp4 ;
35741 int res4 = SWIG_TMPOBJ ;
35742 int temp5 ;
35743 int res5 = SWIG_TMPOBJ ;
35744 int temp6 ;
35745 int res6 = SWIG_TMPOBJ ;
35746 void *argp7 = 0 ;
35747 int res7 = 0 ;
35748 PyObject * obj0 = 0 ;
35749 PyObject * obj1 = 0 ;
35750 PyObject * obj2 = 0 ;
35751 char * kwnames[] = {
35752 (char *) "self",(char *) "string",(char *) "font", NULL
35753 };
35754
35755 arg3 = &temp3;
35756 arg4 = &temp4;
35757 arg5 = &temp5;
35758 arg6 = &temp6;
35759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35761 if (!SWIG_IsOK(res1)) {
35762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35763 }
35764 arg1 = reinterpret_cast< wxWindow * >(argp1);
35765 {
35766 arg2 = wxString_in_helper(obj1);
35767 if (arg2 == NULL) SWIG_fail;
35768 temp2 = true;
35769 }
35770 if (obj2) {
35771 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35772 if (!SWIG_IsOK(res7)) {
35773 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35774 }
35775 arg7 = reinterpret_cast< wxFont * >(argp7);
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 resultobj = SWIG_Py_Void();
35784 if (SWIG_IsTmpObj(res3)) {
35785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35786 } else {
35787 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35789 }
35790 if (SWIG_IsTmpObj(res4)) {
35791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35792 } else {
35793 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35795 }
35796 if (SWIG_IsTmpObj(res5)) {
35797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35798 } else {
35799 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35801 }
35802 if (SWIG_IsTmpObj(res6)) {
35803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35804 } else {
35805 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35807 }
35808 {
35809 if (temp2)
35810 delete arg2;
35811 }
35812 return resultobj;
35813 fail:
35814 {
35815 if (temp2)
35816 delete arg2;
35817 }
35818 return NULL;
35819 }
35820
35821
35822 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35823 PyObject *resultobj = 0;
35824 wxWindow *arg1 = (wxWindow *) 0 ;
35825 int *arg2 = (int *) 0 ;
35826 int *arg3 = (int *) 0 ;
35827 void *argp1 = 0 ;
35828 int res1 = 0 ;
35829 int temp2 ;
35830 int res2 = 0 ;
35831 int temp3 ;
35832 int res3 = 0 ;
35833 PyObject * obj0 = 0 ;
35834 PyObject * obj1 = 0 ;
35835 PyObject * obj2 = 0 ;
35836 char * kwnames[] = {
35837 (char *) "self",(char *) "x",(char *) "y", NULL
35838 };
35839
35840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35842 if (!SWIG_IsOK(res1)) {
35843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35844 }
35845 arg1 = reinterpret_cast< wxWindow * >(argp1);
35846 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35847 int val;
35848 int ecode = SWIG_AsVal_int(obj1, &val);
35849 if (!SWIG_IsOK(ecode)) {
35850 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35851 }
35852 temp2 = static_cast< int >(val);
35853 arg2 = &temp2;
35854 res2 = SWIG_AddTmpMask(ecode);
35855 }
35856 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35857 int val;
35858 int ecode = SWIG_AsVal_int(obj2, &val);
35859 if (!SWIG_IsOK(ecode)) {
35860 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35861 }
35862 temp3 = static_cast< int >(val);
35863 arg3 = &temp3;
35864 res3 = SWIG_AddTmpMask(ecode);
35865 }
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 resultobj = SWIG_Py_Void();
35873 if (SWIG_IsTmpObj(res2)) {
35874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35875 } else {
35876 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35878 }
35879 if (SWIG_IsTmpObj(res3)) {
35880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35881 } else {
35882 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35884 }
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35892 PyObject *resultobj = 0;
35893 wxWindow *arg1 = (wxWindow *) 0 ;
35894 int *arg2 = (int *) 0 ;
35895 int *arg3 = (int *) 0 ;
35896 void *argp1 = 0 ;
35897 int res1 = 0 ;
35898 int temp2 ;
35899 int res2 = 0 ;
35900 int temp3 ;
35901 int res3 = 0 ;
35902 PyObject * obj0 = 0 ;
35903 PyObject * obj1 = 0 ;
35904 PyObject * obj2 = 0 ;
35905 char * kwnames[] = {
35906 (char *) "self",(char *) "x",(char *) "y", NULL
35907 };
35908
35909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35911 if (!SWIG_IsOK(res1)) {
35912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35913 }
35914 arg1 = reinterpret_cast< wxWindow * >(argp1);
35915 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35916 int val;
35917 int ecode = SWIG_AsVal_int(obj1, &val);
35918 if (!SWIG_IsOK(ecode)) {
35919 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35920 }
35921 temp2 = static_cast< int >(val);
35922 arg2 = &temp2;
35923 res2 = SWIG_AddTmpMask(ecode);
35924 }
35925 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35926 int val;
35927 int ecode = SWIG_AsVal_int(obj2, &val);
35928 if (!SWIG_IsOK(ecode)) {
35929 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35930 }
35931 temp3 = static_cast< int >(val);
35932 arg3 = &temp3;
35933 res3 = SWIG_AddTmpMask(ecode);
35934 }
35935 {
35936 PyThreadState* __tstate = wxPyBeginAllowThreads();
35937 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35938 wxPyEndAllowThreads(__tstate);
35939 if (PyErr_Occurred()) SWIG_fail;
35940 }
35941 resultobj = SWIG_Py_Void();
35942 if (SWIG_IsTmpObj(res2)) {
35943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35944 } else {
35945 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35947 }
35948 if (SWIG_IsTmpObj(res3)) {
35949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35950 } else {
35951 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35953 }
35954 return resultobj;
35955 fail:
35956 return NULL;
35957 }
35958
35959
35960 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35961 PyObject *resultobj = 0;
35962 wxWindow *arg1 = (wxWindow *) 0 ;
35963 wxPoint *arg2 = 0 ;
35964 wxPoint result;
35965 void *argp1 = 0 ;
35966 int res1 = 0 ;
35967 wxPoint temp2 ;
35968 PyObject * obj0 = 0 ;
35969 PyObject * obj1 = 0 ;
35970 char * kwnames[] = {
35971 (char *) "self",(char *) "pt", NULL
35972 };
35973
35974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35976 if (!SWIG_IsOK(res1)) {
35977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35978 }
35979 arg1 = reinterpret_cast< wxWindow * >(argp1);
35980 {
35981 arg2 = &temp2;
35982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35983 }
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj = 0;
35999 wxWindow *arg1 = (wxWindow *) 0 ;
36000 wxPoint *arg2 = 0 ;
36001 wxPoint result;
36002 void *argp1 = 0 ;
36003 int res1 = 0 ;
36004 wxPoint temp2 ;
36005 PyObject * obj0 = 0 ;
36006 PyObject * obj1 = 0 ;
36007 char * kwnames[] = {
36008 (char *) "self",(char *) "pt", NULL
36009 };
36010
36011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36013 if (!SWIG_IsOK(res1)) {
36014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36015 }
36016 arg1 = reinterpret_cast< wxWindow * >(argp1);
36017 {
36018 arg2 = &temp2;
36019 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36020 }
36021 {
36022 PyThreadState* __tstate = wxPyBeginAllowThreads();
36023 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36024 wxPyEndAllowThreads(__tstate);
36025 if (PyErr_Occurred()) SWIG_fail;
36026 }
36027 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj = 0;
36036 wxWindow *arg1 = (wxWindow *) 0 ;
36037 int arg2 ;
36038 int arg3 ;
36039 wxHitTest result;
36040 void *argp1 = 0 ;
36041 int res1 = 0 ;
36042 int val2 ;
36043 int ecode2 = 0 ;
36044 int val3 ;
36045 int ecode3 = 0 ;
36046 PyObject * obj0 = 0 ;
36047 PyObject * obj1 = 0 ;
36048 PyObject * obj2 = 0 ;
36049 char * kwnames[] = {
36050 (char *) "self",(char *) "x",(char *) "y", NULL
36051 };
36052
36053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36055 if (!SWIG_IsOK(res1)) {
36056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36057 }
36058 arg1 = reinterpret_cast< wxWindow * >(argp1);
36059 ecode2 = SWIG_AsVal_int(obj1, &val2);
36060 if (!SWIG_IsOK(ecode2)) {
36061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36062 }
36063 arg2 = static_cast< int >(val2);
36064 ecode3 = SWIG_AsVal_int(obj2, &val3);
36065 if (!SWIG_IsOK(ecode3)) {
36066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36067 }
36068 arg3 = static_cast< int >(val3);
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 resultobj = SWIG_From_int(static_cast< int >(result));
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 wxPoint *arg2 = 0 ;
36086 wxHitTest result;
36087 void *argp1 = 0 ;
36088 int res1 = 0 ;
36089 wxPoint temp2 ;
36090 PyObject * obj0 = 0 ;
36091 PyObject * obj1 = 0 ;
36092 char * kwnames[] = {
36093 (char *) "self",(char *) "pt", NULL
36094 };
36095
36096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 {
36103 arg2 = &temp2;
36104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36105 }
36106 {
36107 PyThreadState* __tstate = wxPyBeginAllowThreads();
36108 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36109 wxPyEndAllowThreads(__tstate);
36110 if (PyErr_Occurred()) SWIG_fail;
36111 }
36112 resultobj = SWIG_From_int(static_cast< int >(result));
36113 return resultobj;
36114 fail:
36115 return NULL;
36116 }
36117
36118
36119 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36120 PyObject *resultobj = 0;
36121 wxWindow *arg1 = (wxWindow *) 0 ;
36122 long arg2 ;
36123 wxBorder result;
36124 void *argp1 = 0 ;
36125 int res1 = 0 ;
36126 long val2 ;
36127 int ecode2 = 0 ;
36128
36129 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36136 if (!SWIG_IsOK(ecode2)) {
36137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36138 }
36139 arg2 = static_cast< long >(val2);
36140 {
36141 PyThreadState* __tstate = wxPyBeginAllowThreads();
36142 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36143 wxPyEndAllowThreads(__tstate);
36144 if (PyErr_Occurred()) SWIG_fail;
36145 }
36146 resultobj = SWIG_From_int(static_cast< int >(result));
36147 return resultobj;
36148 fail:
36149 return NULL;
36150 }
36151
36152
36153 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36154 PyObject *resultobj = 0;
36155 wxWindow *arg1 = (wxWindow *) 0 ;
36156 wxBorder result;
36157 void *argp1 = 0 ;
36158 int res1 = 0 ;
36159
36160 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36164 }
36165 arg1 = reinterpret_cast< wxWindow * >(argp1);
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 resultobj = SWIG_From_int(static_cast< int >(result));
36173 return resultobj;
36174 fail:
36175 return NULL;
36176 }
36177
36178
36179 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36180 int argc;
36181 PyObject *argv[3];
36182
36183 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36184 --argc;
36185 if (argc == 1) {
36186 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36187 }
36188 if (argc == 2) {
36189 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36190 }
36191
36192 fail:
36193 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36194 return NULL;
36195 }
36196
36197
36198 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36199 PyObject *resultobj = 0;
36200 wxWindow *arg1 = (wxWindow *) 0 ;
36201 long arg2 = (long) wxUPDATE_UI_NONE ;
36202 void *argp1 = 0 ;
36203 int res1 = 0 ;
36204 long val2 ;
36205 int ecode2 = 0 ;
36206 PyObject * obj0 = 0 ;
36207 PyObject * obj1 = 0 ;
36208 char * kwnames[] = {
36209 (char *) "self",(char *) "flags", NULL
36210 };
36211
36212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36214 if (!SWIG_IsOK(res1)) {
36215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36216 }
36217 arg1 = reinterpret_cast< wxWindow * >(argp1);
36218 if (obj1) {
36219 ecode2 = SWIG_AsVal_long(obj1, &val2);
36220 if (!SWIG_IsOK(ecode2)) {
36221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36222 }
36223 arg2 = static_cast< long >(val2);
36224 }
36225 {
36226 PyThreadState* __tstate = wxPyBeginAllowThreads();
36227 (arg1)->UpdateWindowUI(arg2);
36228 wxPyEndAllowThreads(__tstate);
36229 if (PyErr_Occurred()) SWIG_fail;
36230 }
36231 resultobj = SWIG_Py_Void();
36232 return resultobj;
36233 fail:
36234 return NULL;
36235 }
36236
36237
36238 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36239 PyObject *resultobj = 0;
36240 wxWindow *arg1 = (wxWindow *) 0 ;
36241 wxMenu *arg2 = (wxMenu *) 0 ;
36242 int arg3 = (int) -1 ;
36243 int arg4 = (int) -1 ;
36244 bool result;
36245 void *argp1 = 0 ;
36246 int res1 = 0 ;
36247 void *argp2 = 0 ;
36248 int res2 = 0 ;
36249 int val3 ;
36250 int ecode3 = 0 ;
36251 int val4 ;
36252 int ecode4 = 0 ;
36253 PyObject * obj0 = 0 ;
36254 PyObject * obj1 = 0 ;
36255 PyObject * obj2 = 0 ;
36256 PyObject * obj3 = 0 ;
36257 char * kwnames[] = {
36258 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36259 };
36260
36261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36265 }
36266 arg1 = reinterpret_cast< wxWindow * >(argp1);
36267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36268 if (!SWIG_IsOK(res2)) {
36269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36270 }
36271 arg2 = reinterpret_cast< wxMenu * >(argp2);
36272 if (obj2) {
36273 ecode3 = SWIG_AsVal_int(obj2, &val3);
36274 if (!SWIG_IsOK(ecode3)) {
36275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36276 }
36277 arg3 = static_cast< int >(val3);
36278 }
36279 if (obj3) {
36280 ecode4 = SWIG_AsVal_int(obj3, &val4);
36281 if (!SWIG_IsOK(ecode4)) {
36282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36283 }
36284 arg4 = static_cast< int >(val4);
36285 }
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 {
36293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36294 }
36295 return resultobj;
36296 fail:
36297 return NULL;
36298 }
36299
36300
36301 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36302 PyObject *resultobj = 0;
36303 wxWindow *arg1 = (wxWindow *) 0 ;
36304 wxMenu *arg2 = (wxMenu *) 0 ;
36305 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36306 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36307 bool result;
36308 void *argp1 = 0 ;
36309 int res1 = 0 ;
36310 void *argp2 = 0 ;
36311 int res2 = 0 ;
36312 wxPoint temp3 ;
36313 PyObject * obj0 = 0 ;
36314 PyObject * obj1 = 0 ;
36315 PyObject * obj2 = 0 ;
36316 char * kwnames[] = {
36317 (char *) "self",(char *) "menu",(char *) "pos", NULL
36318 };
36319
36320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36322 if (!SWIG_IsOK(res1)) {
36323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36324 }
36325 arg1 = reinterpret_cast< wxWindow * >(argp1);
36326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36327 if (!SWIG_IsOK(res2)) {
36328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36329 }
36330 arg2 = reinterpret_cast< wxMenu * >(argp2);
36331 if (obj2) {
36332 {
36333 arg3 = &temp3;
36334 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36335 }
36336 }
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 {
36344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36345 }
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36353 PyObject *resultobj = 0;
36354 wxWindow *arg1 = (wxWindow *) 0 ;
36355 bool result;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 PyObject *swig_obj[1] ;
36359
36360 if (!args) SWIG_fail;
36361 swig_obj[0] = args;
36362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36365 }
36366 arg1 = reinterpret_cast< wxWindow * >(argp1);
36367 {
36368 PyThreadState* __tstate = wxPyBeginAllowThreads();
36369 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36370 wxPyEndAllowThreads(__tstate);
36371 if (PyErr_Occurred()) SWIG_fail;
36372 }
36373 {
36374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36375 }
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36383 PyObject *resultobj = 0;
36384 wxWindow *arg1 = (wxWindow *) 0 ;
36385 long result;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 PyObject *swig_obj[1] ;
36389
36390 if (!args) SWIG_fail;
36391 swig_obj[0] = args;
36392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36393 if (!SWIG_IsOK(res1)) {
36394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36395 }
36396 arg1 = reinterpret_cast< wxWindow * >(argp1);
36397 {
36398 PyThreadState* __tstate = wxPyBeginAllowThreads();
36399 result = (long)wxWindow_GetHandle(arg1);
36400 wxPyEndAllowThreads(__tstate);
36401 if (PyErr_Occurred()) SWIG_fail;
36402 }
36403 resultobj = SWIG_From_long(static_cast< long >(result));
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36411 PyObject *resultobj = 0;
36412 wxWindow *arg1 = (wxWindow *) 0 ;
36413 long arg2 ;
36414 void *argp1 = 0 ;
36415 int res1 = 0 ;
36416 long val2 ;
36417 int ecode2 = 0 ;
36418 PyObject * obj0 = 0 ;
36419 PyObject * obj1 = 0 ;
36420 char * kwnames[] = {
36421 (char *) "self",(char *) "handle", NULL
36422 };
36423
36424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36426 if (!SWIG_IsOK(res1)) {
36427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36428 }
36429 arg1 = reinterpret_cast< wxWindow * >(argp1);
36430 ecode2 = SWIG_AsVal_long(obj1, &val2);
36431 if (!SWIG_IsOK(ecode2)) {
36432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36433 }
36434 arg2 = static_cast< long >(val2);
36435 {
36436 PyThreadState* __tstate = wxPyBeginAllowThreads();
36437 wxWindow_AssociateHandle(arg1,arg2);
36438 wxPyEndAllowThreads(__tstate);
36439 if (PyErr_Occurred()) SWIG_fail;
36440 }
36441 resultobj = SWIG_Py_Void();
36442 return resultobj;
36443 fail:
36444 return NULL;
36445 }
36446
36447
36448 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36449 PyObject *resultobj = 0;
36450 wxWindow *arg1 = (wxWindow *) 0 ;
36451 void *argp1 = 0 ;
36452 int res1 = 0 ;
36453 PyObject *swig_obj[1] ;
36454
36455 if (!args) SWIG_fail;
36456 swig_obj[0] = args;
36457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36458 if (!SWIG_IsOK(res1)) {
36459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36460 }
36461 arg1 = reinterpret_cast< wxWindow * >(argp1);
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 (arg1)->DissociateHandle();
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 resultobj = SWIG_Py_Void();
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj = 0;
36477 wxWindow *arg1 = (wxWindow *) 0 ;
36478 int arg2 ;
36479 bool result;
36480 void *argp1 = 0 ;
36481 int res1 = 0 ;
36482 int val2 ;
36483 int ecode2 = 0 ;
36484 PyObject * obj0 = 0 ;
36485 PyObject * obj1 = 0 ;
36486 char * kwnames[] = {
36487 (char *) "self",(char *) "orient", NULL
36488 };
36489
36490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36492 if (!SWIG_IsOK(res1)) {
36493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36494 }
36495 arg1 = reinterpret_cast< wxWindow * >(argp1);
36496 ecode2 = SWIG_AsVal_int(obj1, &val2);
36497 if (!SWIG_IsOK(ecode2)) {
36498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36499 }
36500 arg2 = static_cast< int >(val2);
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 {
36508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36509 }
36510 return resultobj;
36511 fail:
36512 return NULL;
36513 }
36514
36515
36516 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36517 PyObject *resultobj = 0;
36518 wxWindow *arg1 = (wxWindow *) 0 ;
36519 int arg2 ;
36520 int arg3 ;
36521 int arg4 ;
36522 int arg5 ;
36523 bool arg6 = (bool) true ;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 int val2 ;
36527 int ecode2 = 0 ;
36528 int val3 ;
36529 int ecode3 = 0 ;
36530 int val4 ;
36531 int ecode4 = 0 ;
36532 int val5 ;
36533 int ecode5 = 0 ;
36534 bool val6 ;
36535 int ecode6 = 0 ;
36536 PyObject * obj0 = 0 ;
36537 PyObject * obj1 = 0 ;
36538 PyObject * obj2 = 0 ;
36539 PyObject * obj3 = 0 ;
36540 PyObject * obj4 = 0 ;
36541 PyObject * obj5 = 0 ;
36542 char * kwnames[] = {
36543 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36544 };
36545
36546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36548 if (!SWIG_IsOK(res1)) {
36549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36550 }
36551 arg1 = reinterpret_cast< wxWindow * >(argp1);
36552 ecode2 = SWIG_AsVal_int(obj1, &val2);
36553 if (!SWIG_IsOK(ecode2)) {
36554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36555 }
36556 arg2 = static_cast< int >(val2);
36557 ecode3 = SWIG_AsVal_int(obj2, &val3);
36558 if (!SWIG_IsOK(ecode3)) {
36559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36560 }
36561 arg3 = static_cast< int >(val3);
36562 ecode4 = SWIG_AsVal_int(obj3, &val4);
36563 if (!SWIG_IsOK(ecode4)) {
36564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36565 }
36566 arg4 = static_cast< int >(val4);
36567 ecode5 = SWIG_AsVal_int(obj4, &val5);
36568 if (!SWIG_IsOK(ecode5)) {
36569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36570 }
36571 arg5 = static_cast< int >(val5);
36572 if (obj5) {
36573 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36574 if (!SWIG_IsOK(ecode6)) {
36575 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36576 }
36577 arg6 = static_cast< bool >(val6);
36578 }
36579 {
36580 PyThreadState* __tstate = wxPyBeginAllowThreads();
36581 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36582 wxPyEndAllowThreads(__tstate);
36583 if (PyErr_Occurred()) SWIG_fail;
36584 }
36585 resultobj = SWIG_Py_Void();
36586 return resultobj;
36587 fail:
36588 return NULL;
36589 }
36590
36591
36592 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36593 PyObject *resultobj = 0;
36594 wxWindow *arg1 = (wxWindow *) 0 ;
36595 int arg2 ;
36596 int arg3 ;
36597 bool arg4 = (bool) true ;
36598 void *argp1 = 0 ;
36599 int res1 = 0 ;
36600 int val2 ;
36601 int ecode2 = 0 ;
36602 int val3 ;
36603 int ecode3 = 0 ;
36604 bool val4 ;
36605 int ecode4 = 0 ;
36606 PyObject * obj0 = 0 ;
36607 PyObject * obj1 = 0 ;
36608 PyObject * obj2 = 0 ;
36609 PyObject * obj3 = 0 ;
36610 char * kwnames[] = {
36611 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36612 };
36613
36614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36616 if (!SWIG_IsOK(res1)) {
36617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36618 }
36619 arg1 = reinterpret_cast< wxWindow * >(argp1);
36620 ecode2 = SWIG_AsVal_int(obj1, &val2);
36621 if (!SWIG_IsOK(ecode2)) {
36622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36623 }
36624 arg2 = static_cast< int >(val2);
36625 ecode3 = SWIG_AsVal_int(obj2, &val3);
36626 if (!SWIG_IsOK(ecode3)) {
36627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36628 }
36629 arg3 = static_cast< int >(val3);
36630 if (obj3) {
36631 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36632 if (!SWIG_IsOK(ecode4)) {
36633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36634 }
36635 arg4 = static_cast< bool >(val4);
36636 }
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 (arg1)->SetScrollPos(arg2,arg3,arg4);
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 resultobj = SWIG_Py_Void();
36644 return resultobj;
36645 fail:
36646 return NULL;
36647 }
36648
36649
36650 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36651 PyObject *resultobj = 0;
36652 wxWindow *arg1 = (wxWindow *) 0 ;
36653 int arg2 ;
36654 int result;
36655 void *argp1 = 0 ;
36656 int res1 = 0 ;
36657 int val2 ;
36658 int ecode2 = 0 ;
36659 PyObject * obj0 = 0 ;
36660 PyObject * obj1 = 0 ;
36661 char * kwnames[] = {
36662 (char *) "self",(char *) "orientation", NULL
36663 };
36664
36665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 ecode2 = SWIG_AsVal_int(obj1, &val2);
36672 if (!SWIG_IsOK(ecode2)) {
36673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36674 }
36675 arg2 = static_cast< int >(val2);
36676 {
36677 PyThreadState* __tstate = wxPyBeginAllowThreads();
36678 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36679 wxPyEndAllowThreads(__tstate);
36680 if (PyErr_Occurred()) SWIG_fail;
36681 }
36682 resultobj = SWIG_From_int(static_cast< int >(result));
36683 return resultobj;
36684 fail:
36685 return NULL;
36686 }
36687
36688
36689 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36690 PyObject *resultobj = 0;
36691 wxWindow *arg1 = (wxWindow *) 0 ;
36692 int arg2 ;
36693 int result;
36694 void *argp1 = 0 ;
36695 int res1 = 0 ;
36696 int val2 ;
36697 int ecode2 = 0 ;
36698 PyObject * obj0 = 0 ;
36699 PyObject * obj1 = 0 ;
36700 char * kwnames[] = {
36701 (char *) "self",(char *) "orientation", NULL
36702 };
36703
36704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36706 if (!SWIG_IsOK(res1)) {
36707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36708 }
36709 arg1 = reinterpret_cast< wxWindow * >(argp1);
36710 ecode2 = SWIG_AsVal_int(obj1, &val2);
36711 if (!SWIG_IsOK(ecode2)) {
36712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36713 }
36714 arg2 = static_cast< int >(val2);
36715 {
36716 PyThreadState* __tstate = wxPyBeginAllowThreads();
36717 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36718 wxPyEndAllowThreads(__tstate);
36719 if (PyErr_Occurred()) SWIG_fail;
36720 }
36721 resultobj = SWIG_From_int(static_cast< int >(result));
36722 return resultobj;
36723 fail:
36724 return NULL;
36725 }
36726
36727
36728 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36729 PyObject *resultobj = 0;
36730 wxWindow *arg1 = (wxWindow *) 0 ;
36731 int arg2 ;
36732 int result;
36733 void *argp1 = 0 ;
36734 int res1 = 0 ;
36735 int val2 ;
36736 int ecode2 = 0 ;
36737 PyObject * obj0 = 0 ;
36738 PyObject * obj1 = 0 ;
36739 char * kwnames[] = {
36740 (char *) "self",(char *) "orientation", NULL
36741 };
36742
36743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36745 if (!SWIG_IsOK(res1)) {
36746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36747 }
36748 arg1 = reinterpret_cast< wxWindow * >(argp1);
36749 ecode2 = SWIG_AsVal_int(obj1, &val2);
36750 if (!SWIG_IsOK(ecode2)) {
36751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36752 }
36753 arg2 = static_cast< int >(val2);
36754 {
36755 PyThreadState* __tstate = wxPyBeginAllowThreads();
36756 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36757 wxPyEndAllowThreads(__tstate);
36758 if (PyErr_Occurred()) SWIG_fail;
36759 }
36760 resultobj = SWIG_From_int(static_cast< int >(result));
36761 return resultobj;
36762 fail:
36763 return NULL;
36764 }
36765
36766
36767 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36768 PyObject *resultobj = 0;
36769 wxWindow *arg1 = (wxWindow *) 0 ;
36770 int arg2 ;
36771 int arg3 ;
36772 wxRect *arg4 = (wxRect *) NULL ;
36773 void *argp1 = 0 ;
36774 int res1 = 0 ;
36775 int val2 ;
36776 int ecode2 = 0 ;
36777 int val3 ;
36778 int ecode3 = 0 ;
36779 void *argp4 = 0 ;
36780 int res4 = 0 ;
36781 PyObject * obj0 = 0 ;
36782 PyObject * obj1 = 0 ;
36783 PyObject * obj2 = 0 ;
36784 PyObject * obj3 = 0 ;
36785 char * kwnames[] = {
36786 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36787 };
36788
36789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36791 if (!SWIG_IsOK(res1)) {
36792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36793 }
36794 arg1 = reinterpret_cast< wxWindow * >(argp1);
36795 ecode2 = SWIG_AsVal_int(obj1, &val2);
36796 if (!SWIG_IsOK(ecode2)) {
36797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36798 }
36799 arg2 = static_cast< int >(val2);
36800 ecode3 = SWIG_AsVal_int(obj2, &val3);
36801 if (!SWIG_IsOK(ecode3)) {
36802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36803 }
36804 arg3 = static_cast< int >(val3);
36805 if (obj3) {
36806 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36807 if (!SWIG_IsOK(res4)) {
36808 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36809 }
36810 arg4 = reinterpret_cast< wxRect * >(argp4);
36811 }
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36815 wxPyEndAllowThreads(__tstate);
36816 if (PyErr_Occurred()) SWIG_fail;
36817 }
36818 resultobj = SWIG_Py_Void();
36819 return resultobj;
36820 fail:
36821 return NULL;
36822 }
36823
36824
36825 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36826 PyObject *resultobj = 0;
36827 wxWindow *arg1 = (wxWindow *) 0 ;
36828 int arg2 ;
36829 bool result;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 int val2 ;
36833 int ecode2 = 0 ;
36834 PyObject * obj0 = 0 ;
36835 PyObject * obj1 = 0 ;
36836 char * kwnames[] = {
36837 (char *) "self",(char *) "lines", NULL
36838 };
36839
36840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36842 if (!SWIG_IsOK(res1)) {
36843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36844 }
36845 arg1 = reinterpret_cast< wxWindow * >(argp1);
36846 ecode2 = SWIG_AsVal_int(obj1, &val2);
36847 if (!SWIG_IsOK(ecode2)) {
36848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36849 }
36850 arg2 = static_cast< int >(val2);
36851 {
36852 PyThreadState* __tstate = wxPyBeginAllowThreads();
36853 result = (bool)(arg1)->ScrollLines(arg2);
36854 wxPyEndAllowThreads(__tstate);
36855 if (PyErr_Occurred()) SWIG_fail;
36856 }
36857 {
36858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36859 }
36860 return resultobj;
36861 fail:
36862 return NULL;
36863 }
36864
36865
36866 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36867 PyObject *resultobj = 0;
36868 wxWindow *arg1 = (wxWindow *) 0 ;
36869 int arg2 ;
36870 bool result;
36871 void *argp1 = 0 ;
36872 int res1 = 0 ;
36873 int val2 ;
36874 int ecode2 = 0 ;
36875 PyObject * obj0 = 0 ;
36876 PyObject * obj1 = 0 ;
36877 char * kwnames[] = {
36878 (char *) "self",(char *) "pages", NULL
36879 };
36880
36881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36883 if (!SWIG_IsOK(res1)) {
36884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36885 }
36886 arg1 = reinterpret_cast< wxWindow * >(argp1);
36887 ecode2 = SWIG_AsVal_int(obj1, &val2);
36888 if (!SWIG_IsOK(ecode2)) {
36889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36890 }
36891 arg2 = static_cast< int >(val2);
36892 {
36893 PyThreadState* __tstate = wxPyBeginAllowThreads();
36894 result = (bool)(arg1)->ScrollPages(arg2);
36895 wxPyEndAllowThreads(__tstate);
36896 if (PyErr_Occurred()) SWIG_fail;
36897 }
36898 {
36899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36900 }
36901 return resultobj;
36902 fail:
36903 return NULL;
36904 }
36905
36906
36907 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36908 PyObject *resultobj = 0;
36909 wxWindow *arg1 = (wxWindow *) 0 ;
36910 bool result;
36911 void *argp1 = 0 ;
36912 int res1 = 0 ;
36913 PyObject *swig_obj[1] ;
36914
36915 if (!args) SWIG_fail;
36916 swig_obj[0] = args;
36917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 result = (bool)(arg1)->LineUp();
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 {
36929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36930 }
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36938 PyObject *resultobj = 0;
36939 wxWindow *arg1 = (wxWindow *) 0 ;
36940 bool result;
36941 void *argp1 = 0 ;
36942 int res1 = 0 ;
36943 PyObject *swig_obj[1] ;
36944
36945 if (!args) SWIG_fail;
36946 swig_obj[0] = args;
36947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36948 if (!SWIG_IsOK(res1)) {
36949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36950 }
36951 arg1 = reinterpret_cast< wxWindow * >(argp1);
36952 {
36953 PyThreadState* __tstate = wxPyBeginAllowThreads();
36954 result = (bool)(arg1)->LineDown();
36955 wxPyEndAllowThreads(__tstate);
36956 if (PyErr_Occurred()) SWIG_fail;
36957 }
36958 {
36959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36960 }
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36968 PyObject *resultobj = 0;
36969 wxWindow *arg1 = (wxWindow *) 0 ;
36970 bool result;
36971 void *argp1 = 0 ;
36972 int res1 = 0 ;
36973 PyObject *swig_obj[1] ;
36974
36975 if (!args) SWIG_fail;
36976 swig_obj[0] = args;
36977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36978 if (!SWIG_IsOK(res1)) {
36979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36980 }
36981 arg1 = reinterpret_cast< wxWindow * >(argp1);
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 result = (bool)(arg1)->PageUp();
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 {
36989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36990 }
36991 return resultobj;
36992 fail:
36993 return NULL;
36994 }
36995
36996
36997 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36998 PyObject *resultobj = 0;
36999 wxWindow *arg1 = (wxWindow *) 0 ;
37000 bool result;
37001 void *argp1 = 0 ;
37002 int res1 = 0 ;
37003 PyObject *swig_obj[1] ;
37004
37005 if (!args) SWIG_fail;
37006 swig_obj[0] = args;
37007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37008 if (!SWIG_IsOK(res1)) {
37009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37010 }
37011 arg1 = reinterpret_cast< wxWindow * >(argp1);
37012 {
37013 PyThreadState* __tstate = wxPyBeginAllowThreads();
37014 result = (bool)(arg1)->PageDown();
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 {
37019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37020 }
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj = 0;
37029 wxWindow *arg1 = (wxWindow *) 0 ;
37030 wxString *arg2 = 0 ;
37031 void *argp1 = 0 ;
37032 int res1 = 0 ;
37033 bool temp2 = false ;
37034 PyObject * obj0 = 0 ;
37035 PyObject * obj1 = 0 ;
37036 char * kwnames[] = {
37037 (char *) "self",(char *) "text", NULL
37038 };
37039
37040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37042 if (!SWIG_IsOK(res1)) {
37043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37044 }
37045 arg1 = reinterpret_cast< wxWindow * >(argp1);
37046 {
37047 arg2 = wxString_in_helper(obj1);
37048 if (arg2 == NULL) SWIG_fail;
37049 temp2 = true;
37050 }
37051 {
37052 PyThreadState* __tstate = wxPyBeginAllowThreads();
37053 (arg1)->SetHelpText((wxString const &)*arg2);
37054 wxPyEndAllowThreads(__tstate);
37055 if (PyErr_Occurred()) SWIG_fail;
37056 }
37057 resultobj = SWIG_Py_Void();
37058 {
37059 if (temp2)
37060 delete arg2;
37061 }
37062 return resultobj;
37063 fail:
37064 {
37065 if (temp2)
37066 delete arg2;
37067 }
37068 return NULL;
37069 }
37070
37071
37072 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37073 PyObject *resultobj = 0;
37074 wxWindow *arg1 = (wxWindow *) 0 ;
37075 wxString *arg2 = 0 ;
37076 void *argp1 = 0 ;
37077 int res1 = 0 ;
37078 bool temp2 = false ;
37079 PyObject * obj0 = 0 ;
37080 PyObject * obj1 = 0 ;
37081 char * kwnames[] = {
37082 (char *) "self",(char *) "text", NULL
37083 };
37084
37085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37087 if (!SWIG_IsOK(res1)) {
37088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37089 }
37090 arg1 = reinterpret_cast< wxWindow * >(argp1);
37091 {
37092 arg2 = wxString_in_helper(obj1);
37093 if (arg2 == NULL) SWIG_fail;
37094 temp2 = true;
37095 }
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 resultobj = SWIG_Py_Void();
37103 {
37104 if (temp2)
37105 delete arg2;
37106 }
37107 return resultobj;
37108 fail:
37109 {
37110 if (temp2)
37111 delete arg2;
37112 }
37113 return NULL;
37114 }
37115
37116
37117 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37118 PyObject *resultobj = 0;
37119 wxWindow *arg1 = (wxWindow *) 0 ;
37120 wxPoint *arg2 = 0 ;
37121 wxHelpEvent::Origin arg3 ;
37122 wxString result;
37123 void *argp1 = 0 ;
37124 int res1 = 0 ;
37125 wxPoint temp2 ;
37126 void *argp3 ;
37127 int res3 = 0 ;
37128 PyObject * obj0 = 0 ;
37129 PyObject * obj1 = 0 ;
37130 PyObject * obj2 = 0 ;
37131 char * kwnames[] = {
37132 (char *) "self",(char *) "pt",(char *) "origin", NULL
37133 };
37134
37135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37137 if (!SWIG_IsOK(res1)) {
37138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37139 }
37140 arg1 = reinterpret_cast< wxWindow * >(argp1);
37141 {
37142 arg2 = &temp2;
37143 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37144 }
37145 {
37146 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37147 if (!SWIG_IsOK(res3)) {
37148 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37149 }
37150 if (!argp3) {
37151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37152 } else {
37153 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37154 arg3 = *temp;
37155 if (SWIG_IsNewObj(res3)) delete temp;
37156 }
37157 }
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 {
37165 #if wxUSE_UNICODE
37166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37167 #else
37168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37169 #endif
37170 }
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37178 PyObject *resultobj = 0;
37179 wxWindow *arg1 = (wxWindow *) 0 ;
37180 wxString result;
37181 void *argp1 = 0 ;
37182 int res1 = 0 ;
37183 PyObject *swig_obj[1] ;
37184
37185 if (!args) SWIG_fail;
37186 swig_obj[0] = args;
37187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37188 if (!SWIG_IsOK(res1)) {
37189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37190 }
37191 arg1 = reinterpret_cast< wxWindow * >(argp1);
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 result = ((wxWindow const *)arg1)->GetHelpText();
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 {
37199 #if wxUSE_UNICODE
37200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37201 #else
37202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37203 #endif
37204 }
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37212 PyObject *resultobj = 0;
37213 wxWindow *arg1 = (wxWindow *) 0 ;
37214 wxString *arg2 = 0 ;
37215 void *argp1 = 0 ;
37216 int res1 = 0 ;
37217 bool temp2 = false ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "tip", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 {
37231 arg2 = wxString_in_helper(obj1);
37232 if (arg2 == NULL) SWIG_fail;
37233 temp2 = true;
37234 }
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 (arg1)->SetToolTip((wxString const &)*arg2);
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 resultobj = SWIG_Py_Void();
37242 {
37243 if (temp2)
37244 delete arg2;
37245 }
37246 return resultobj;
37247 fail:
37248 {
37249 if (temp2)
37250 delete arg2;
37251 }
37252 return NULL;
37253 }
37254
37255
37256 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj = 0;
37258 wxWindow *arg1 = (wxWindow *) 0 ;
37259 wxToolTip *arg2 = (wxToolTip *) 0 ;
37260 void *argp1 = 0 ;
37261 int res1 = 0 ;
37262 int res2 = 0 ;
37263 PyObject * obj0 = 0 ;
37264 PyObject * obj1 = 0 ;
37265 char * kwnames[] = {
37266 (char *) "self",(char *) "tip", NULL
37267 };
37268
37269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37271 if (!SWIG_IsOK(res1)) {
37272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37273 }
37274 arg1 = reinterpret_cast< wxWindow * >(argp1);
37275 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37276 if (!SWIG_IsOK(res2)) {
37277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37278 }
37279 {
37280 PyThreadState* __tstate = wxPyBeginAllowThreads();
37281 (arg1)->SetToolTip(arg2);
37282 wxPyEndAllowThreads(__tstate);
37283 if (PyErr_Occurred()) SWIG_fail;
37284 }
37285 resultobj = SWIG_Py_Void();
37286 return resultobj;
37287 fail:
37288 return NULL;
37289 }
37290
37291
37292 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37293 PyObject *resultobj = 0;
37294 wxWindow *arg1 = (wxWindow *) 0 ;
37295 wxToolTip *result = 0 ;
37296 void *argp1 = 0 ;
37297 int res1 = 0 ;
37298 PyObject *swig_obj[1] ;
37299
37300 if (!args) SWIG_fail;
37301 swig_obj[0] = args;
37302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37303 if (!SWIG_IsOK(res1)) {
37304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37305 }
37306 arg1 = reinterpret_cast< wxWindow * >(argp1);
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37310 wxPyEndAllowThreads(__tstate);
37311 if (PyErr_Occurred()) SWIG_fail;
37312 }
37313 {
37314 resultobj = wxPyMake_wxObject(result, (bool)0);
37315 }
37316 return resultobj;
37317 fail:
37318 return NULL;
37319 }
37320
37321
37322 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37323 PyObject *resultobj = 0;
37324 wxWindow *arg1 = (wxWindow *) 0 ;
37325 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37326 void *argp1 = 0 ;
37327 int res1 = 0 ;
37328 int res2 = 0 ;
37329 PyObject * obj0 = 0 ;
37330 PyObject * obj1 = 0 ;
37331 char * kwnames[] = {
37332 (char *) "self",(char *) "dropTarget", NULL
37333 };
37334
37335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37337 if (!SWIG_IsOK(res1)) {
37338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37339 }
37340 arg1 = reinterpret_cast< wxWindow * >(argp1);
37341 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37342 if (!SWIG_IsOK(res2)) {
37343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37344 }
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 (arg1)->SetDropTarget(arg2);
37348 wxPyEndAllowThreads(__tstate);
37349 if (PyErr_Occurred()) SWIG_fail;
37350 }
37351 resultobj = SWIG_Py_Void();
37352 return resultobj;
37353 fail:
37354 return NULL;
37355 }
37356
37357
37358 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37359 PyObject *resultobj = 0;
37360 wxWindow *arg1 = (wxWindow *) 0 ;
37361 wxPyDropTarget *result = 0 ;
37362 void *argp1 = 0 ;
37363 int res1 = 0 ;
37364 PyObject *swig_obj[1] ;
37365
37366 if (!args) SWIG_fail;
37367 swig_obj[0] = args;
37368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37369 if (!SWIG_IsOK(res1)) {
37370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37371 }
37372 arg1 = reinterpret_cast< wxWindow * >(argp1);
37373 {
37374 PyThreadState* __tstate = wxPyBeginAllowThreads();
37375 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37376 wxPyEndAllowThreads(__tstate);
37377 if (PyErr_Occurred()) SWIG_fail;
37378 }
37379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37380 return resultobj;
37381 fail:
37382 return NULL;
37383 }
37384
37385
37386 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37387 PyObject *resultobj = 0;
37388 wxWindow *arg1 = (wxWindow *) 0 ;
37389 bool arg2 ;
37390 void *argp1 = 0 ;
37391 int res1 = 0 ;
37392 bool val2 ;
37393 int ecode2 = 0 ;
37394 PyObject * obj0 = 0 ;
37395 PyObject * obj1 = 0 ;
37396 char * kwnames[] = {
37397 (char *) "self",(char *) "accept", NULL
37398 };
37399
37400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37402 if (!SWIG_IsOK(res1)) {
37403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37404 }
37405 arg1 = reinterpret_cast< wxWindow * >(argp1);
37406 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37407 if (!SWIG_IsOK(ecode2)) {
37408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37409 }
37410 arg2 = static_cast< bool >(val2);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 wxWindow_DragAcceptFiles(arg1,arg2);
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = SWIG_Py_Void();
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37425 PyObject *resultobj = 0;
37426 wxWindow *arg1 = (wxWindow *) 0 ;
37427 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 int res2 = 0 ;
37431 PyObject * obj0 = 0 ;
37432 PyObject * obj1 = 0 ;
37433 char * kwnames[] = {
37434 (char *) "self",(char *) "constraints", NULL
37435 };
37436
37437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37439 if (!SWIG_IsOK(res1)) {
37440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37441 }
37442 arg1 = reinterpret_cast< wxWindow * >(argp1);
37443 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37444 if (!SWIG_IsOK(res2)) {
37445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37446 }
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 (arg1)->SetConstraints(arg2);
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 resultobj = SWIG_Py_Void();
37454 return resultobj;
37455 fail:
37456 return NULL;
37457 }
37458
37459
37460 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37461 PyObject *resultobj = 0;
37462 wxWindow *arg1 = (wxWindow *) 0 ;
37463 wxLayoutConstraints *result = 0 ;
37464 void *argp1 = 0 ;
37465 int res1 = 0 ;
37466 PyObject *swig_obj[1] ;
37467
37468 if (!args) SWIG_fail;
37469 swig_obj[0] = args;
37470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37471 if (!SWIG_IsOK(res1)) {
37472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37473 }
37474 arg1 = reinterpret_cast< wxWindow * >(argp1);
37475 {
37476 PyThreadState* __tstate = wxPyBeginAllowThreads();
37477 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37478 wxPyEndAllowThreads(__tstate);
37479 if (PyErr_Occurred()) SWIG_fail;
37480 }
37481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37482 return resultobj;
37483 fail:
37484 return NULL;
37485 }
37486
37487
37488 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37489 PyObject *resultobj = 0;
37490 wxWindow *arg1 = (wxWindow *) 0 ;
37491 bool arg2 ;
37492 void *argp1 = 0 ;
37493 int res1 = 0 ;
37494 bool val2 ;
37495 int ecode2 = 0 ;
37496 PyObject * obj0 = 0 ;
37497 PyObject * obj1 = 0 ;
37498 char * kwnames[] = {
37499 (char *) "self",(char *) "autoLayout", NULL
37500 };
37501
37502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37504 if (!SWIG_IsOK(res1)) {
37505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37506 }
37507 arg1 = reinterpret_cast< wxWindow * >(argp1);
37508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37509 if (!SWIG_IsOK(ecode2)) {
37510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37511 }
37512 arg2 = static_cast< bool >(val2);
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->SetAutoLayout(arg2);
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_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37527 PyObject *resultobj = 0;
37528 wxWindow *arg1 = (wxWindow *) 0 ;
37529 bool result;
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_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37539 }
37540 arg1 = reinterpret_cast< wxWindow * >(argp1);
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 {
37548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37549 }
37550 return resultobj;
37551 fail:
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37557 PyObject *resultobj = 0;
37558 wxWindow *arg1 = (wxWindow *) 0 ;
37559 bool result;
37560 void *argp1 = 0 ;
37561 int res1 = 0 ;
37562 PyObject *swig_obj[1] ;
37563
37564 if (!args) SWIG_fail;
37565 swig_obj[0] = args;
37566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37567 if (!SWIG_IsOK(res1)) {
37568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37569 }
37570 arg1 = reinterpret_cast< wxWindow * >(argp1);
37571 {
37572 PyThreadState* __tstate = wxPyBeginAllowThreads();
37573 result = (bool)(arg1)->Layout();
37574 wxPyEndAllowThreads(__tstate);
37575 if (PyErr_Occurred()) SWIG_fail;
37576 }
37577 {
37578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37579 }
37580 return resultobj;
37581 fail:
37582 return NULL;
37583 }
37584
37585
37586 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37587 PyObject *resultobj = 0;
37588 wxWindow *arg1 = (wxWindow *) 0 ;
37589 wxSizer *arg2 = (wxSizer *) 0 ;
37590 bool arg3 = (bool) true ;
37591 void *argp1 = 0 ;
37592 int res1 = 0 ;
37593 int res2 = 0 ;
37594 bool val3 ;
37595 int ecode3 = 0 ;
37596 PyObject * obj0 = 0 ;
37597 PyObject * obj1 = 0 ;
37598 PyObject * obj2 = 0 ;
37599 char * kwnames[] = {
37600 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37601 };
37602
37603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37607 }
37608 arg1 = reinterpret_cast< wxWindow * >(argp1);
37609 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37610 if (!SWIG_IsOK(res2)) {
37611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37612 }
37613 if (obj2) {
37614 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37615 if (!SWIG_IsOK(ecode3)) {
37616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37617 }
37618 arg3 = static_cast< bool >(val3);
37619 }
37620 {
37621 PyThreadState* __tstate = wxPyBeginAllowThreads();
37622 (arg1)->SetSizer(arg2,arg3);
37623 wxPyEndAllowThreads(__tstate);
37624 if (PyErr_Occurred()) SWIG_fail;
37625 }
37626 resultobj = SWIG_Py_Void();
37627 return resultobj;
37628 fail:
37629 return NULL;
37630 }
37631
37632
37633 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37634 PyObject *resultobj = 0;
37635 wxWindow *arg1 = (wxWindow *) 0 ;
37636 wxSizer *arg2 = (wxSizer *) 0 ;
37637 bool arg3 = (bool) true ;
37638 void *argp1 = 0 ;
37639 int res1 = 0 ;
37640 int res2 = 0 ;
37641 bool val3 ;
37642 int ecode3 = 0 ;
37643 PyObject * obj0 = 0 ;
37644 PyObject * obj1 = 0 ;
37645 PyObject * obj2 = 0 ;
37646 char * kwnames[] = {
37647 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37648 };
37649
37650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37652 if (!SWIG_IsOK(res1)) {
37653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37654 }
37655 arg1 = reinterpret_cast< wxWindow * >(argp1);
37656 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37657 if (!SWIG_IsOK(res2)) {
37658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37659 }
37660 if (obj2) {
37661 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37662 if (!SWIG_IsOK(ecode3)) {
37663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37664 }
37665 arg3 = static_cast< bool >(val3);
37666 }
37667 {
37668 PyThreadState* __tstate = wxPyBeginAllowThreads();
37669 (arg1)->SetSizerAndFit(arg2,arg3);
37670 wxPyEndAllowThreads(__tstate);
37671 if (PyErr_Occurred()) SWIG_fail;
37672 }
37673 resultobj = SWIG_Py_Void();
37674 return resultobj;
37675 fail:
37676 return NULL;
37677 }
37678
37679
37680 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37681 PyObject *resultobj = 0;
37682 wxWindow *arg1 = (wxWindow *) 0 ;
37683 wxSizer *result = 0 ;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 PyObject *swig_obj[1] ;
37687
37688 if (!args) SWIG_fail;
37689 swig_obj[0] = args;
37690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37691 if (!SWIG_IsOK(res1)) {
37692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37693 }
37694 arg1 = reinterpret_cast< wxWindow * >(argp1);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 {
37702 resultobj = wxPyMake_wxObject(result, (bool)0);
37703 }
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj = 0;
37712 wxWindow *arg1 = (wxWindow *) 0 ;
37713 wxSizer *arg2 = (wxSizer *) 0 ;
37714 void *argp1 = 0 ;
37715 int res1 = 0 ;
37716 void *argp2 = 0 ;
37717 int res2 = 0 ;
37718 PyObject * obj0 = 0 ;
37719 PyObject * obj1 = 0 ;
37720 char * kwnames[] = {
37721 (char *) "self",(char *) "sizer", NULL
37722 };
37723
37724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37726 if (!SWIG_IsOK(res1)) {
37727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37728 }
37729 arg1 = reinterpret_cast< wxWindow * >(argp1);
37730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37731 if (!SWIG_IsOK(res2)) {
37732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37733 }
37734 arg2 = reinterpret_cast< wxSizer * >(argp2);
37735 {
37736 PyThreadState* __tstate = wxPyBeginAllowThreads();
37737 (arg1)->SetContainingSizer(arg2);
37738 wxPyEndAllowThreads(__tstate);
37739 if (PyErr_Occurred()) SWIG_fail;
37740 }
37741 resultobj = SWIG_Py_Void();
37742 return resultobj;
37743 fail:
37744 return NULL;
37745 }
37746
37747
37748 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37749 PyObject *resultobj = 0;
37750 wxWindow *arg1 = (wxWindow *) 0 ;
37751 wxSizer *result = 0 ;
37752 void *argp1 = 0 ;
37753 int res1 = 0 ;
37754 PyObject *swig_obj[1] ;
37755
37756 if (!args) SWIG_fail;
37757 swig_obj[0] = args;
37758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37759 if (!SWIG_IsOK(res1)) {
37760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37761 }
37762 arg1 = reinterpret_cast< wxWindow * >(argp1);
37763 {
37764 PyThreadState* __tstate = wxPyBeginAllowThreads();
37765 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37766 wxPyEndAllowThreads(__tstate);
37767 if (PyErr_Occurred()) SWIG_fail;
37768 }
37769 {
37770 resultobj = wxPyMake_wxObject(result, (bool)0);
37771 }
37772 return resultobj;
37773 fail:
37774 return NULL;
37775 }
37776
37777
37778 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37779 PyObject *resultobj = 0;
37780 wxWindow *arg1 = (wxWindow *) 0 ;
37781 void *argp1 = 0 ;
37782 int res1 = 0 ;
37783 PyObject *swig_obj[1] ;
37784
37785 if (!args) SWIG_fail;
37786 swig_obj[0] = args;
37787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37788 if (!SWIG_IsOK(res1)) {
37789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37790 }
37791 arg1 = reinterpret_cast< wxWindow * >(argp1);
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 (arg1)->InheritAttributes();
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 resultobj = SWIG_Py_Void();
37799 return resultobj;
37800 fail:
37801 return NULL;
37802 }
37803
37804
37805 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37806 PyObject *resultobj = 0;
37807 wxWindow *arg1 = (wxWindow *) 0 ;
37808 bool result;
37809 void *argp1 = 0 ;
37810 int res1 = 0 ;
37811 PyObject *swig_obj[1] ;
37812
37813 if (!args) SWIG_fail;
37814 swig_obj[0] = args;
37815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37816 if (!SWIG_IsOK(res1)) {
37817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37818 }
37819 arg1 = reinterpret_cast< wxWindow * >(argp1);
37820 {
37821 PyThreadState* __tstate = wxPyBeginAllowThreads();
37822 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37823 wxPyEndAllowThreads(__tstate);
37824 if (PyErr_Occurred()) SWIG_fail;
37825 }
37826 {
37827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37828 }
37829 return resultobj;
37830 fail:
37831 return NULL;
37832 }
37833
37834
37835 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37836 PyObject *resultobj = 0;
37837 wxWindow *arg1 = (wxWindow *) 0 ;
37838 bool result;
37839 void *argp1 = 0 ;
37840 int res1 = 0 ;
37841 PyObject *swig_obj[1] ;
37842
37843 if (!args) SWIG_fail;
37844 swig_obj[0] = args;
37845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37846 if (!SWIG_IsOK(res1)) {
37847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37848 }
37849 arg1 = reinterpret_cast< wxWindow * >(argp1);
37850 {
37851 PyThreadState* __tstate = wxPyBeginAllowThreads();
37852 result = (bool)(arg1)->CanSetTransparent();
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 {
37857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37858 }
37859 return resultobj;
37860 fail:
37861 return NULL;
37862 }
37863
37864
37865 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37866 PyObject *resultobj = 0;
37867 wxWindow *arg1 = (wxWindow *) 0 ;
37868 byte arg2 ;
37869 bool result;
37870 void *argp1 = 0 ;
37871 int res1 = 0 ;
37872 unsigned char val2 ;
37873 int ecode2 = 0 ;
37874 PyObject * obj0 = 0 ;
37875 PyObject * obj1 = 0 ;
37876 char * kwnames[] = {
37877 (char *) "self",(char *) "alpha", NULL
37878 };
37879
37880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37882 if (!SWIG_IsOK(res1)) {
37883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37884 }
37885 arg1 = reinterpret_cast< wxWindow * >(argp1);
37886 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37887 if (!SWIG_IsOK(ecode2)) {
37888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37889 }
37890 arg2 = static_cast< byte >(val2);
37891 {
37892 PyThreadState* __tstate = wxPyBeginAllowThreads();
37893 result = (bool)(arg1)->SetTransparent(arg2);
37894 wxPyEndAllowThreads(__tstate);
37895 if (PyErr_Occurred()) SWIG_fail;
37896 }
37897 {
37898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37899 }
37900 return resultobj;
37901 fail:
37902 return NULL;
37903 }
37904
37905
37906 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37907 PyObject *obj;
37908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37909 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37910 return SWIG_Py_Void();
37911 }
37912
37913 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37914 return SWIG_Python_InitShadowInstance(args);
37915 }
37916
37917 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37918 PyObject *resultobj = 0;
37919 long arg1 ;
37920 wxWindow *arg2 = (wxWindow *) NULL ;
37921 wxWindow *result = 0 ;
37922 long val1 ;
37923 int ecode1 = 0 ;
37924 void *argp2 = 0 ;
37925 int res2 = 0 ;
37926 PyObject * obj0 = 0 ;
37927 PyObject * obj1 = 0 ;
37928 char * kwnames[] = {
37929 (char *) "id",(char *) "parent", NULL
37930 };
37931
37932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37933 ecode1 = SWIG_AsVal_long(obj0, &val1);
37934 if (!SWIG_IsOK(ecode1)) {
37935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37936 }
37937 arg1 = static_cast< long >(val1);
37938 if (obj1) {
37939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37940 if (!SWIG_IsOK(res2)) {
37941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37942 }
37943 arg2 = reinterpret_cast< wxWindow * >(argp2);
37944 }
37945 {
37946 if (!wxPyCheckForApp()) SWIG_fail;
37947 PyThreadState* __tstate = wxPyBeginAllowThreads();
37948 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37949 wxPyEndAllowThreads(__tstate);
37950 if (PyErr_Occurred()) SWIG_fail;
37951 }
37952 {
37953 resultobj = wxPyMake_wxObject(result, 0);
37954 }
37955 return resultobj;
37956 fail:
37957 return NULL;
37958 }
37959
37960
37961 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37962 PyObject *resultobj = 0;
37963 wxString *arg1 = 0 ;
37964 wxWindow *arg2 = (wxWindow *) NULL ;
37965 wxWindow *result = 0 ;
37966 bool temp1 = false ;
37967 void *argp2 = 0 ;
37968 int res2 = 0 ;
37969 PyObject * obj0 = 0 ;
37970 PyObject * obj1 = 0 ;
37971 char * kwnames[] = {
37972 (char *) "name",(char *) "parent", NULL
37973 };
37974
37975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37976 {
37977 arg1 = wxString_in_helper(obj0);
37978 if (arg1 == NULL) SWIG_fail;
37979 temp1 = true;
37980 }
37981 if (obj1) {
37982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37983 if (!SWIG_IsOK(res2)) {
37984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37985 }
37986 arg2 = reinterpret_cast< wxWindow * >(argp2);
37987 }
37988 {
37989 if (!wxPyCheckForApp()) SWIG_fail;
37990 PyThreadState* __tstate = wxPyBeginAllowThreads();
37991 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37992 wxPyEndAllowThreads(__tstate);
37993 if (PyErr_Occurred()) SWIG_fail;
37994 }
37995 {
37996 resultobj = wxPyMake_wxObject(result, 0);
37997 }
37998 {
37999 if (temp1)
38000 delete arg1;
38001 }
38002 return resultobj;
38003 fail:
38004 {
38005 if (temp1)
38006 delete arg1;
38007 }
38008 return NULL;
38009 }
38010
38011
38012 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38013 PyObject *resultobj = 0;
38014 wxString *arg1 = 0 ;
38015 wxWindow *arg2 = (wxWindow *) NULL ;
38016 wxWindow *result = 0 ;
38017 bool temp1 = false ;
38018 void *argp2 = 0 ;
38019 int res2 = 0 ;
38020 PyObject * obj0 = 0 ;
38021 PyObject * obj1 = 0 ;
38022 char * kwnames[] = {
38023 (char *) "label",(char *) "parent", NULL
38024 };
38025
38026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38027 {
38028 arg1 = wxString_in_helper(obj0);
38029 if (arg1 == NULL) SWIG_fail;
38030 temp1 = true;
38031 }
38032 if (obj1) {
38033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38034 if (!SWIG_IsOK(res2)) {
38035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38036 }
38037 arg2 = reinterpret_cast< wxWindow * >(argp2);
38038 }
38039 {
38040 if (!wxPyCheckForApp()) SWIG_fail;
38041 PyThreadState* __tstate = wxPyBeginAllowThreads();
38042 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38043 wxPyEndAllowThreads(__tstate);
38044 if (PyErr_Occurred()) SWIG_fail;
38045 }
38046 {
38047 resultobj = wxPyMake_wxObject(result, 0);
38048 }
38049 {
38050 if (temp1)
38051 delete arg1;
38052 }
38053 return resultobj;
38054 fail:
38055 {
38056 if (temp1)
38057 delete arg1;
38058 }
38059 return NULL;
38060 }
38061
38062
38063 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38064 PyObject *resultobj = 0;
38065 wxWindow *arg1 = (wxWindow *) 0 ;
38066 unsigned long arg2 ;
38067 wxWindow *result = 0 ;
38068 void *argp1 = 0 ;
38069 int res1 = 0 ;
38070 unsigned long val2 ;
38071 int ecode2 = 0 ;
38072 PyObject * obj0 = 0 ;
38073 PyObject * obj1 = 0 ;
38074 char * kwnames[] = {
38075 (char *) "parent",(char *) "_hWnd", NULL
38076 };
38077
38078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38080 if (!SWIG_IsOK(res1)) {
38081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38082 }
38083 arg1 = reinterpret_cast< wxWindow * >(argp1);
38084 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38085 if (!SWIG_IsOK(ecode2)) {
38086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38087 }
38088 arg2 = static_cast< unsigned long >(val2);
38089 {
38090 PyThreadState* __tstate = wxPyBeginAllowThreads();
38091 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 {
38096 resultobj = wxPyMake_wxObject(result, 0);
38097 }
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38105 PyObject *resultobj = 0;
38106 PyObject *result = 0 ;
38107
38108 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38109 {
38110 PyThreadState* __tstate = wxPyBeginAllowThreads();
38111 result = (PyObject *)GetTopLevelWindows();
38112 wxPyEndAllowThreads(__tstate);
38113 if (PyErr_Occurred()) SWIG_fail;
38114 }
38115 resultobj = result;
38116 return resultobj;
38117 fail:
38118 return NULL;
38119 }
38120
38121
38122 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38123 PyObject *resultobj = 0;
38124 wxValidator *result = 0 ;
38125
38126 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 result = (wxValidator *)new wxValidator();
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38134 return resultobj;
38135 fail:
38136 return NULL;
38137 }
38138
38139
38140 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38141 PyObject *resultobj = 0;
38142 wxValidator *arg1 = (wxValidator *) 0 ;
38143 wxValidator *result = 0 ;
38144 void *argp1 = 0 ;
38145 int res1 = 0 ;
38146 PyObject *swig_obj[1] ;
38147
38148 if (!args) SWIG_fail;
38149 swig_obj[0] = args;
38150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38151 if (!SWIG_IsOK(res1)) {
38152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38153 }
38154 arg1 = reinterpret_cast< wxValidator * >(argp1);
38155 {
38156 PyThreadState* __tstate = wxPyBeginAllowThreads();
38157 result = (wxValidator *)(arg1)->Clone();
38158 wxPyEndAllowThreads(__tstate);
38159 if (PyErr_Occurred()) SWIG_fail;
38160 }
38161 {
38162 resultobj = wxPyMake_wxObject(result, 0);
38163 }
38164 return resultobj;
38165 fail:
38166 return NULL;
38167 }
38168
38169
38170 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38171 PyObject *resultobj = 0;
38172 wxValidator *arg1 = (wxValidator *) 0 ;
38173 wxWindow *arg2 = (wxWindow *) 0 ;
38174 bool result;
38175 void *argp1 = 0 ;
38176 int res1 = 0 ;
38177 void *argp2 = 0 ;
38178 int res2 = 0 ;
38179 PyObject * obj0 = 0 ;
38180 PyObject * obj1 = 0 ;
38181 char * kwnames[] = {
38182 (char *) "self",(char *) "parent", NULL
38183 };
38184
38185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38187 if (!SWIG_IsOK(res1)) {
38188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38189 }
38190 arg1 = reinterpret_cast< wxValidator * >(argp1);
38191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38192 if (!SWIG_IsOK(res2)) {
38193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38194 }
38195 arg2 = reinterpret_cast< wxWindow * >(argp2);
38196 {
38197 PyThreadState* __tstate = wxPyBeginAllowThreads();
38198 result = (bool)(arg1)->Validate(arg2);
38199 wxPyEndAllowThreads(__tstate);
38200 if (PyErr_Occurred()) SWIG_fail;
38201 }
38202 {
38203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38204 }
38205 return resultobj;
38206 fail:
38207 return NULL;
38208 }
38209
38210
38211 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38212 PyObject *resultobj = 0;
38213 wxValidator *arg1 = (wxValidator *) 0 ;
38214 bool result;
38215 void *argp1 = 0 ;
38216 int res1 = 0 ;
38217 PyObject *swig_obj[1] ;
38218
38219 if (!args) SWIG_fail;
38220 swig_obj[0] = args;
38221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38222 if (!SWIG_IsOK(res1)) {
38223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38224 }
38225 arg1 = reinterpret_cast< wxValidator * >(argp1);
38226 {
38227 PyThreadState* __tstate = wxPyBeginAllowThreads();
38228 result = (bool)(arg1)->TransferToWindow();
38229 wxPyEndAllowThreads(__tstate);
38230 if (PyErr_Occurred()) SWIG_fail;
38231 }
38232 {
38233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38234 }
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38242 PyObject *resultobj = 0;
38243 wxValidator *arg1 = (wxValidator *) 0 ;
38244 bool result;
38245 void *argp1 = 0 ;
38246 int res1 = 0 ;
38247 PyObject *swig_obj[1] ;
38248
38249 if (!args) SWIG_fail;
38250 swig_obj[0] = args;
38251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38252 if (!SWIG_IsOK(res1)) {
38253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38254 }
38255 arg1 = reinterpret_cast< wxValidator * >(argp1);
38256 {
38257 PyThreadState* __tstate = wxPyBeginAllowThreads();
38258 result = (bool)(arg1)->TransferFromWindow();
38259 wxPyEndAllowThreads(__tstate);
38260 if (PyErr_Occurred()) SWIG_fail;
38261 }
38262 {
38263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38264 }
38265 return resultobj;
38266 fail:
38267 return NULL;
38268 }
38269
38270
38271 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38272 PyObject *resultobj = 0;
38273 wxValidator *arg1 = (wxValidator *) 0 ;
38274 wxWindow *result = 0 ;
38275 void *argp1 = 0 ;
38276 int res1 = 0 ;
38277 PyObject *swig_obj[1] ;
38278
38279 if (!args) SWIG_fail;
38280 swig_obj[0] = args;
38281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38282 if (!SWIG_IsOK(res1)) {
38283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38284 }
38285 arg1 = reinterpret_cast< wxValidator * >(argp1);
38286 {
38287 PyThreadState* __tstate = wxPyBeginAllowThreads();
38288 result = (wxWindow *)(arg1)->GetWindow();
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 {
38293 resultobj = wxPyMake_wxObject(result, 0);
38294 }
38295 return resultobj;
38296 fail:
38297 return NULL;
38298 }
38299
38300
38301 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38302 PyObject *resultobj = 0;
38303 wxValidator *arg1 = (wxValidator *) 0 ;
38304 wxWindow *arg2 = (wxWindow *) 0 ;
38305 void *argp1 = 0 ;
38306 int res1 = 0 ;
38307 void *argp2 = 0 ;
38308 int res2 = 0 ;
38309 PyObject * obj0 = 0 ;
38310 PyObject * obj1 = 0 ;
38311 char * kwnames[] = {
38312 (char *) "self",(char *) "window", NULL
38313 };
38314
38315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38317 if (!SWIG_IsOK(res1)) {
38318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38319 }
38320 arg1 = reinterpret_cast< wxValidator * >(argp1);
38321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38322 if (!SWIG_IsOK(res2)) {
38323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38324 }
38325 arg2 = reinterpret_cast< wxWindow * >(argp2);
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 (arg1)->SetWindow(arg2);
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 resultobj = SWIG_Py_Void();
38333 return resultobj;
38334 fail:
38335 return NULL;
38336 }
38337
38338
38339 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38340 PyObject *resultobj = 0;
38341 bool result;
38342
38343 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (bool)wxValidator::IsSilent();
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 {
38351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38352 }
38353 return resultobj;
38354 fail:
38355 return NULL;
38356 }
38357
38358
38359 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38360 PyObject *resultobj = 0;
38361 int arg1 = (int) true ;
38362 int val1 ;
38363 int ecode1 = 0 ;
38364 PyObject * obj0 = 0 ;
38365 char * kwnames[] = {
38366 (char *) "doIt", NULL
38367 };
38368
38369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38370 if (obj0) {
38371 ecode1 = SWIG_AsVal_int(obj0, &val1);
38372 if (!SWIG_IsOK(ecode1)) {
38373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38374 }
38375 arg1 = static_cast< int >(val1);
38376 }
38377 {
38378 PyThreadState* __tstate = wxPyBeginAllowThreads();
38379 wxValidator::SetBellOnError(arg1);
38380 wxPyEndAllowThreads(__tstate);
38381 if (PyErr_Occurred()) SWIG_fail;
38382 }
38383 resultobj = SWIG_Py_Void();
38384 return resultobj;
38385 fail:
38386 return NULL;
38387 }
38388
38389
38390 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38391 PyObject *obj;
38392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38393 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38394 return SWIG_Py_Void();
38395 }
38396
38397 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38398 return SWIG_Python_InitShadowInstance(args);
38399 }
38400
38401 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38402 PyObject *resultobj = 0;
38403 wxPyValidator *result = 0 ;
38404
38405 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38406 {
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 result = (wxPyValidator *)new wxPyValidator();
38409 wxPyEndAllowThreads(__tstate);
38410 if (PyErr_Occurred()) SWIG_fail;
38411 }
38412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38413 return resultobj;
38414 fail:
38415 return NULL;
38416 }
38417
38418
38419 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38420 PyObject *resultobj = 0;
38421 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38422 PyObject *arg2 = (PyObject *) 0 ;
38423 PyObject *arg3 = (PyObject *) 0 ;
38424 int arg4 = (int) true ;
38425 void *argp1 = 0 ;
38426 int res1 = 0 ;
38427 int val4 ;
38428 int ecode4 = 0 ;
38429 PyObject * obj0 = 0 ;
38430 PyObject * obj1 = 0 ;
38431 PyObject * obj2 = 0 ;
38432 PyObject * obj3 = 0 ;
38433 char * kwnames[] = {
38434 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38435 };
38436
38437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38439 if (!SWIG_IsOK(res1)) {
38440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38441 }
38442 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38443 arg2 = obj1;
38444 arg3 = obj2;
38445 if (obj3) {
38446 ecode4 = SWIG_AsVal_int(obj3, &val4);
38447 if (!SWIG_IsOK(ecode4)) {
38448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38449 }
38450 arg4 = static_cast< int >(val4);
38451 }
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 resultobj = SWIG_Py_Void();
38459 return resultobj;
38460 fail:
38461 return NULL;
38462 }
38463
38464
38465 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38466 PyObject *obj;
38467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38468 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38469 return SWIG_Py_Void();
38470 }
38471
38472 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38473 return SWIG_Python_InitShadowInstance(args);
38474 }
38475
38476 SWIGINTERN int DefaultValidator_set(PyObject *) {
38477 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38478 return 1;
38479 }
38480
38481
38482 SWIGINTERN PyObject *DefaultValidator_get(void) {
38483 PyObject *pyobj = 0;
38484
38485 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38486 return pyobj;
38487 }
38488
38489
38490 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38491 PyObject *resultobj = 0;
38492 wxString const &arg1_defvalue = wxPyEmptyString ;
38493 wxString *arg1 = (wxString *) &arg1_defvalue ;
38494 long arg2 = (long) 0 ;
38495 wxMenu *result = 0 ;
38496 bool temp1 = false ;
38497 long val2 ;
38498 int ecode2 = 0 ;
38499 PyObject * obj0 = 0 ;
38500 PyObject * obj1 = 0 ;
38501 char * kwnames[] = {
38502 (char *) "title",(char *) "style", NULL
38503 };
38504
38505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38506 if (obj0) {
38507 {
38508 arg1 = wxString_in_helper(obj0);
38509 if (arg1 == NULL) SWIG_fail;
38510 temp1 = true;
38511 }
38512 }
38513 if (obj1) {
38514 ecode2 = SWIG_AsVal_long(obj1, &val2);
38515 if (!SWIG_IsOK(ecode2)) {
38516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38517 }
38518 arg2 = static_cast< long >(val2);
38519 }
38520 {
38521 if (!wxPyCheckForApp()) SWIG_fail;
38522 PyThreadState* __tstate = wxPyBeginAllowThreads();
38523 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38524 wxPyEndAllowThreads(__tstate);
38525 if (PyErr_Occurred()) SWIG_fail;
38526 }
38527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38528 {
38529 if (temp1)
38530 delete arg1;
38531 }
38532 return resultobj;
38533 fail:
38534 {
38535 if (temp1)
38536 delete arg1;
38537 }
38538 return NULL;
38539 }
38540
38541
38542 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38543 PyObject *resultobj = 0;
38544 wxMenu *arg1 = (wxMenu *) 0 ;
38545 int arg2 ;
38546 wxString *arg3 = 0 ;
38547 wxString const &arg4_defvalue = wxPyEmptyString ;
38548 wxString *arg4 = (wxString *) &arg4_defvalue ;
38549 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38550 wxMenuItem *result = 0 ;
38551 void *argp1 = 0 ;
38552 int res1 = 0 ;
38553 int val2 ;
38554 int ecode2 = 0 ;
38555 bool temp3 = false ;
38556 bool temp4 = false ;
38557 int val5 ;
38558 int ecode5 = 0 ;
38559 PyObject * obj0 = 0 ;
38560 PyObject * obj1 = 0 ;
38561 PyObject * obj2 = 0 ;
38562 PyObject * obj3 = 0 ;
38563 PyObject * obj4 = 0 ;
38564 char * kwnames[] = {
38565 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38566 };
38567
38568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38570 if (!SWIG_IsOK(res1)) {
38571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38572 }
38573 arg1 = reinterpret_cast< wxMenu * >(argp1);
38574 ecode2 = SWIG_AsVal_int(obj1, &val2);
38575 if (!SWIG_IsOK(ecode2)) {
38576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38577 }
38578 arg2 = static_cast< int >(val2);
38579 {
38580 arg3 = wxString_in_helper(obj2);
38581 if (arg3 == NULL) SWIG_fail;
38582 temp3 = true;
38583 }
38584 if (obj3) {
38585 {
38586 arg4 = wxString_in_helper(obj3);
38587 if (arg4 == NULL) SWIG_fail;
38588 temp4 = true;
38589 }
38590 }
38591 if (obj4) {
38592 ecode5 = SWIG_AsVal_int(obj4, &val5);
38593 if (!SWIG_IsOK(ecode5)) {
38594 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38595 }
38596 arg5 = static_cast< wxItemKind >(val5);
38597 }
38598 {
38599 PyThreadState* __tstate = wxPyBeginAllowThreads();
38600 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38601 wxPyEndAllowThreads(__tstate);
38602 if (PyErr_Occurred()) SWIG_fail;
38603 }
38604 {
38605 resultobj = wxPyMake_wxObject(result, (bool)0);
38606 }
38607 {
38608 if (temp3)
38609 delete arg3;
38610 }
38611 {
38612 if (temp4)
38613 delete arg4;
38614 }
38615 return resultobj;
38616 fail:
38617 {
38618 if (temp3)
38619 delete arg3;
38620 }
38621 {
38622 if (temp4)
38623 delete arg4;
38624 }
38625 return NULL;
38626 }
38627
38628
38629 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38630 PyObject *resultobj = 0;
38631 wxMenu *arg1 = (wxMenu *) 0 ;
38632 wxMenuItem *result = 0 ;
38633 void *argp1 = 0 ;
38634 int res1 = 0 ;
38635 PyObject *swig_obj[1] ;
38636
38637 if (!args) SWIG_fail;
38638 swig_obj[0] = args;
38639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38640 if (!SWIG_IsOK(res1)) {
38641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38642 }
38643 arg1 = reinterpret_cast< wxMenu * >(argp1);
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (wxMenuItem *)(arg1)->AppendSeparator();
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 {
38651 resultobj = wxPyMake_wxObject(result, (bool)0);
38652 }
38653 return resultobj;
38654 fail:
38655 return NULL;
38656 }
38657
38658
38659 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38660 PyObject *resultobj = 0;
38661 wxMenu *arg1 = (wxMenu *) 0 ;
38662 int arg2 ;
38663 wxString *arg3 = 0 ;
38664 wxString const &arg4_defvalue = wxPyEmptyString ;
38665 wxString *arg4 = (wxString *) &arg4_defvalue ;
38666 wxMenuItem *result = 0 ;
38667 void *argp1 = 0 ;
38668 int res1 = 0 ;
38669 int val2 ;
38670 int ecode2 = 0 ;
38671 bool temp3 = false ;
38672 bool temp4 = false ;
38673 PyObject * obj0 = 0 ;
38674 PyObject * obj1 = 0 ;
38675 PyObject * obj2 = 0 ;
38676 PyObject * obj3 = 0 ;
38677 char * kwnames[] = {
38678 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38679 };
38680
38681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38683 if (!SWIG_IsOK(res1)) {
38684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38685 }
38686 arg1 = reinterpret_cast< wxMenu * >(argp1);
38687 ecode2 = SWIG_AsVal_int(obj1, &val2);
38688 if (!SWIG_IsOK(ecode2)) {
38689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38690 }
38691 arg2 = static_cast< int >(val2);
38692 {
38693 arg3 = wxString_in_helper(obj2);
38694 if (arg3 == NULL) SWIG_fail;
38695 temp3 = true;
38696 }
38697 if (obj3) {
38698 {
38699 arg4 = wxString_in_helper(obj3);
38700 if (arg4 == NULL) SWIG_fail;
38701 temp4 = true;
38702 }
38703 }
38704 {
38705 PyThreadState* __tstate = wxPyBeginAllowThreads();
38706 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38707 wxPyEndAllowThreads(__tstate);
38708 if (PyErr_Occurred()) SWIG_fail;
38709 }
38710 {
38711 resultobj = wxPyMake_wxObject(result, (bool)0);
38712 }
38713 {
38714 if (temp3)
38715 delete arg3;
38716 }
38717 {
38718 if (temp4)
38719 delete arg4;
38720 }
38721 return resultobj;
38722 fail:
38723 {
38724 if (temp3)
38725 delete arg3;
38726 }
38727 {
38728 if (temp4)
38729 delete arg4;
38730 }
38731 return NULL;
38732 }
38733
38734
38735 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38736 PyObject *resultobj = 0;
38737 wxMenu *arg1 = (wxMenu *) 0 ;
38738 int arg2 ;
38739 wxString *arg3 = 0 ;
38740 wxString const &arg4_defvalue = wxPyEmptyString ;
38741 wxString *arg4 = (wxString *) &arg4_defvalue ;
38742 wxMenuItem *result = 0 ;
38743 void *argp1 = 0 ;
38744 int res1 = 0 ;
38745 int val2 ;
38746 int ecode2 = 0 ;
38747 bool temp3 = false ;
38748 bool temp4 = false ;
38749 PyObject * obj0 = 0 ;
38750 PyObject * obj1 = 0 ;
38751 PyObject * obj2 = 0 ;
38752 PyObject * obj3 = 0 ;
38753 char * kwnames[] = {
38754 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38755 };
38756
38757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38761 }
38762 arg1 = reinterpret_cast< wxMenu * >(argp1);
38763 ecode2 = SWIG_AsVal_int(obj1, &val2);
38764 if (!SWIG_IsOK(ecode2)) {
38765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38766 }
38767 arg2 = static_cast< int >(val2);
38768 {
38769 arg3 = wxString_in_helper(obj2);
38770 if (arg3 == NULL) SWIG_fail;
38771 temp3 = true;
38772 }
38773 if (obj3) {
38774 {
38775 arg4 = wxString_in_helper(obj3);
38776 if (arg4 == NULL) SWIG_fail;
38777 temp4 = true;
38778 }
38779 }
38780 {
38781 PyThreadState* __tstate = wxPyBeginAllowThreads();
38782 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38783 wxPyEndAllowThreads(__tstate);
38784 if (PyErr_Occurred()) SWIG_fail;
38785 }
38786 {
38787 resultobj = wxPyMake_wxObject(result, (bool)0);
38788 }
38789 {
38790 if (temp3)
38791 delete arg3;
38792 }
38793 {
38794 if (temp4)
38795 delete arg4;
38796 }
38797 return resultobj;
38798 fail:
38799 {
38800 if (temp3)
38801 delete arg3;
38802 }
38803 {
38804 if (temp4)
38805 delete arg4;
38806 }
38807 return NULL;
38808 }
38809
38810
38811 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38812 PyObject *resultobj = 0;
38813 wxMenu *arg1 = (wxMenu *) 0 ;
38814 int arg2 ;
38815 wxString *arg3 = 0 ;
38816 wxMenu *arg4 = (wxMenu *) 0 ;
38817 wxString const &arg5_defvalue = wxPyEmptyString ;
38818 wxString *arg5 = (wxString *) &arg5_defvalue ;
38819 wxMenuItem *result = 0 ;
38820 void *argp1 = 0 ;
38821 int res1 = 0 ;
38822 int val2 ;
38823 int ecode2 = 0 ;
38824 bool temp3 = false ;
38825 void *argp4 = 0 ;
38826 int res4 = 0 ;
38827 bool temp5 = false ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 PyObject * obj2 = 0 ;
38831 PyObject * obj3 = 0 ;
38832 PyObject * obj4 = 0 ;
38833 char * kwnames[] = {
38834 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38835 };
38836
38837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38839 if (!SWIG_IsOK(res1)) {
38840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38841 }
38842 arg1 = reinterpret_cast< wxMenu * >(argp1);
38843 ecode2 = SWIG_AsVal_int(obj1, &val2);
38844 if (!SWIG_IsOK(ecode2)) {
38845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38846 }
38847 arg2 = static_cast< int >(val2);
38848 {
38849 arg3 = wxString_in_helper(obj2);
38850 if (arg3 == NULL) SWIG_fail;
38851 temp3 = true;
38852 }
38853 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38854 if (!SWIG_IsOK(res4)) {
38855 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38856 }
38857 arg4 = reinterpret_cast< wxMenu * >(argp4);
38858 if (obj4) {
38859 {
38860 arg5 = wxString_in_helper(obj4);
38861 if (arg5 == NULL) SWIG_fail;
38862 temp5 = true;
38863 }
38864 }
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 {
38872 resultobj = wxPyMake_wxObject(result, (bool)0);
38873 }
38874 {
38875 if (temp3)
38876 delete arg3;
38877 }
38878 {
38879 if (temp5)
38880 delete arg5;
38881 }
38882 return resultobj;
38883 fail:
38884 {
38885 if (temp3)
38886 delete arg3;
38887 }
38888 {
38889 if (temp5)
38890 delete arg5;
38891 }
38892 return NULL;
38893 }
38894
38895
38896 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38897 PyObject *resultobj = 0;
38898 wxMenu *arg1 = (wxMenu *) 0 ;
38899 wxMenu *arg2 = (wxMenu *) 0 ;
38900 wxString *arg3 = 0 ;
38901 wxString const &arg4_defvalue = wxPyEmptyString ;
38902 wxString *arg4 = (wxString *) &arg4_defvalue ;
38903 wxMenuItem *result = 0 ;
38904 void *argp1 = 0 ;
38905 int res1 = 0 ;
38906 void *argp2 = 0 ;
38907 int res2 = 0 ;
38908 bool temp3 = false ;
38909 bool temp4 = false ;
38910 PyObject * obj0 = 0 ;
38911 PyObject * obj1 = 0 ;
38912 PyObject * obj2 = 0 ;
38913 PyObject * obj3 = 0 ;
38914 char * kwnames[] = {
38915 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38916 };
38917
38918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38920 if (!SWIG_IsOK(res1)) {
38921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38922 }
38923 arg1 = reinterpret_cast< wxMenu * >(argp1);
38924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38925 if (!SWIG_IsOK(res2)) {
38926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38927 }
38928 arg2 = reinterpret_cast< wxMenu * >(argp2);
38929 {
38930 arg3 = wxString_in_helper(obj2);
38931 if (arg3 == NULL) SWIG_fail;
38932 temp3 = true;
38933 }
38934 if (obj3) {
38935 {
38936 arg4 = wxString_in_helper(obj3);
38937 if (arg4 == NULL) SWIG_fail;
38938 temp4 = true;
38939 }
38940 }
38941 {
38942 PyThreadState* __tstate = wxPyBeginAllowThreads();
38943 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38944 wxPyEndAllowThreads(__tstate);
38945 if (PyErr_Occurred()) SWIG_fail;
38946 }
38947 {
38948 resultobj = wxPyMake_wxObject(result, (bool)0);
38949 }
38950 {
38951 if (temp3)
38952 delete arg3;
38953 }
38954 {
38955 if (temp4)
38956 delete arg4;
38957 }
38958 return resultobj;
38959 fail:
38960 {
38961 if (temp3)
38962 delete arg3;
38963 }
38964 {
38965 if (temp4)
38966 delete arg4;
38967 }
38968 return NULL;
38969 }
38970
38971
38972 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38973 PyObject *resultobj = 0;
38974 wxMenu *arg1 = (wxMenu *) 0 ;
38975 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38976 wxMenuItem *result = 0 ;
38977 void *argp1 = 0 ;
38978 int res1 = 0 ;
38979 int res2 = 0 ;
38980 PyObject * obj0 = 0 ;
38981 PyObject * obj1 = 0 ;
38982 char * kwnames[] = {
38983 (char *) "self",(char *) "item", NULL
38984 };
38985
38986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38988 if (!SWIG_IsOK(res1)) {
38989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38990 }
38991 arg1 = reinterpret_cast< wxMenu * >(argp1);
38992 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38993 if (!SWIG_IsOK(res2)) {
38994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38995 }
38996 {
38997 PyThreadState* __tstate = wxPyBeginAllowThreads();
38998 result = (wxMenuItem *)(arg1)->Append(arg2);
38999 wxPyEndAllowThreads(__tstate);
39000 if (PyErr_Occurred()) SWIG_fail;
39001 }
39002 {
39003 resultobj = wxPyMake_wxObject(result, (bool)0);
39004 }
39005 return resultobj;
39006 fail:
39007 return NULL;
39008 }
39009
39010
39011 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39012 PyObject *resultobj = 0;
39013 wxMenu *arg1 = (wxMenu *) 0 ;
39014 size_t arg2 ;
39015 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39016 wxMenuItem *result = 0 ;
39017 void *argp1 = 0 ;
39018 int res1 = 0 ;
39019 size_t val2 ;
39020 int ecode2 = 0 ;
39021 int res3 = 0 ;
39022 PyObject * obj0 = 0 ;
39023 PyObject * obj1 = 0 ;
39024 PyObject * obj2 = 0 ;
39025 char * kwnames[] = {
39026 (char *) "self",(char *) "pos",(char *) "item", NULL
39027 };
39028
39029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39031 if (!SWIG_IsOK(res1)) {
39032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39033 }
39034 arg1 = reinterpret_cast< wxMenu * >(argp1);
39035 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39036 if (!SWIG_IsOK(ecode2)) {
39037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39038 }
39039 arg2 = static_cast< size_t >(val2);
39040 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39041 if (!SWIG_IsOK(res3)) {
39042 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39043 }
39044 {
39045 PyThreadState* __tstate = wxPyBeginAllowThreads();
39046 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 {
39051 resultobj = wxPyMake_wxObject(result, (bool)0);
39052 }
39053 return resultobj;
39054 fail:
39055 return NULL;
39056 }
39057
39058
39059 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39060 PyObject *resultobj = 0;
39061 wxMenu *arg1 = (wxMenu *) 0 ;
39062 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39063 wxMenuItem *result = 0 ;
39064 void *argp1 = 0 ;
39065 int res1 = 0 ;
39066 int res2 = 0 ;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 char * kwnames[] = {
39070 (char *) "self",(char *) "item", NULL
39071 };
39072
39073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39075 if (!SWIG_IsOK(res1)) {
39076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39077 }
39078 arg1 = reinterpret_cast< wxMenu * >(argp1);
39079 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39080 if (!SWIG_IsOK(res2)) {
39081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39082 }
39083 {
39084 PyThreadState* __tstate = wxPyBeginAllowThreads();
39085 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 {
39090 resultobj = wxPyMake_wxObject(result, (bool)0);
39091 }
39092 return resultobj;
39093 fail:
39094 return NULL;
39095 }
39096
39097
39098 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39099 PyObject *resultobj = 0;
39100 wxMenu *arg1 = (wxMenu *) 0 ;
39101 void *argp1 = 0 ;
39102 int res1 = 0 ;
39103 PyObject *swig_obj[1] ;
39104
39105 if (!args) SWIG_fail;
39106 swig_obj[0] = args;
39107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39108 if (!SWIG_IsOK(res1)) {
39109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39110 }
39111 arg1 = reinterpret_cast< wxMenu * >(argp1);
39112 {
39113 PyThreadState* __tstate = wxPyBeginAllowThreads();
39114 (arg1)->Break();
39115 wxPyEndAllowThreads(__tstate);
39116 if (PyErr_Occurred()) SWIG_fail;
39117 }
39118 resultobj = SWIG_Py_Void();
39119 return resultobj;
39120 fail:
39121 return NULL;
39122 }
39123
39124
39125 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39126 PyObject *resultobj = 0;
39127 wxMenu *arg1 = (wxMenu *) 0 ;
39128 size_t arg2 ;
39129 int arg3 ;
39130 wxString *arg4 = 0 ;
39131 wxString const &arg5_defvalue = wxPyEmptyString ;
39132 wxString *arg5 = (wxString *) &arg5_defvalue ;
39133 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39134 wxMenuItem *result = 0 ;
39135 void *argp1 = 0 ;
39136 int res1 = 0 ;
39137 size_t val2 ;
39138 int ecode2 = 0 ;
39139 int val3 ;
39140 int ecode3 = 0 ;
39141 bool temp4 = false ;
39142 bool temp5 = false ;
39143 int val6 ;
39144 int ecode6 = 0 ;
39145 PyObject * obj0 = 0 ;
39146 PyObject * obj1 = 0 ;
39147 PyObject * obj2 = 0 ;
39148 PyObject * obj3 = 0 ;
39149 PyObject * obj4 = 0 ;
39150 PyObject * obj5 = 0 ;
39151 char * kwnames[] = {
39152 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39153 };
39154
39155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39157 if (!SWIG_IsOK(res1)) {
39158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39159 }
39160 arg1 = reinterpret_cast< wxMenu * >(argp1);
39161 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39162 if (!SWIG_IsOK(ecode2)) {
39163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39164 }
39165 arg2 = static_cast< size_t >(val2);
39166 ecode3 = SWIG_AsVal_int(obj2, &val3);
39167 if (!SWIG_IsOK(ecode3)) {
39168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39169 }
39170 arg3 = static_cast< int >(val3);
39171 {
39172 arg4 = wxString_in_helper(obj3);
39173 if (arg4 == NULL) SWIG_fail;
39174 temp4 = true;
39175 }
39176 if (obj4) {
39177 {
39178 arg5 = wxString_in_helper(obj4);
39179 if (arg5 == NULL) SWIG_fail;
39180 temp5 = true;
39181 }
39182 }
39183 if (obj5) {
39184 ecode6 = SWIG_AsVal_int(obj5, &val6);
39185 if (!SWIG_IsOK(ecode6)) {
39186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39187 }
39188 arg6 = static_cast< wxItemKind >(val6);
39189 }
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39193 wxPyEndAllowThreads(__tstate);
39194 if (PyErr_Occurred()) SWIG_fail;
39195 }
39196 {
39197 resultobj = wxPyMake_wxObject(result, (bool)0);
39198 }
39199 {
39200 if (temp4)
39201 delete arg4;
39202 }
39203 {
39204 if (temp5)
39205 delete arg5;
39206 }
39207 return resultobj;
39208 fail:
39209 {
39210 if (temp4)
39211 delete arg4;
39212 }
39213 {
39214 if (temp5)
39215 delete arg5;
39216 }
39217 return NULL;
39218 }
39219
39220
39221 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39222 PyObject *resultobj = 0;
39223 wxMenu *arg1 = (wxMenu *) 0 ;
39224 size_t arg2 ;
39225 wxMenuItem *result = 0 ;
39226 void *argp1 = 0 ;
39227 int res1 = 0 ;
39228 size_t val2 ;
39229 int ecode2 = 0 ;
39230 PyObject * obj0 = 0 ;
39231 PyObject * obj1 = 0 ;
39232 char * kwnames[] = {
39233 (char *) "self",(char *) "pos", NULL
39234 };
39235
39236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39238 if (!SWIG_IsOK(res1)) {
39239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39240 }
39241 arg1 = reinterpret_cast< wxMenu * >(argp1);
39242 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39243 if (!SWIG_IsOK(ecode2)) {
39244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39245 }
39246 arg2 = static_cast< size_t >(val2);
39247 {
39248 PyThreadState* __tstate = wxPyBeginAllowThreads();
39249 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39250 wxPyEndAllowThreads(__tstate);
39251 if (PyErr_Occurred()) SWIG_fail;
39252 }
39253 {
39254 resultobj = wxPyMake_wxObject(result, (bool)0);
39255 }
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39263 PyObject *resultobj = 0;
39264 wxMenu *arg1 = (wxMenu *) 0 ;
39265 size_t arg2 ;
39266 int arg3 ;
39267 wxString *arg4 = 0 ;
39268 wxString const &arg5_defvalue = wxPyEmptyString ;
39269 wxString *arg5 = (wxString *) &arg5_defvalue ;
39270 wxMenuItem *result = 0 ;
39271 void *argp1 = 0 ;
39272 int res1 = 0 ;
39273 size_t val2 ;
39274 int ecode2 = 0 ;
39275 int val3 ;
39276 int ecode3 = 0 ;
39277 bool temp4 = false ;
39278 bool temp5 = false ;
39279 PyObject * obj0 = 0 ;
39280 PyObject * obj1 = 0 ;
39281 PyObject * obj2 = 0 ;
39282 PyObject * obj3 = 0 ;
39283 PyObject * obj4 = 0 ;
39284 char * kwnames[] = {
39285 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39286 };
39287
39288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39290 if (!SWIG_IsOK(res1)) {
39291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39292 }
39293 arg1 = reinterpret_cast< wxMenu * >(argp1);
39294 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39295 if (!SWIG_IsOK(ecode2)) {
39296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39297 }
39298 arg2 = static_cast< size_t >(val2);
39299 ecode3 = SWIG_AsVal_int(obj2, &val3);
39300 if (!SWIG_IsOK(ecode3)) {
39301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39302 }
39303 arg3 = static_cast< int >(val3);
39304 {
39305 arg4 = wxString_in_helper(obj3);
39306 if (arg4 == NULL) SWIG_fail;
39307 temp4 = true;
39308 }
39309 if (obj4) {
39310 {
39311 arg5 = wxString_in_helper(obj4);
39312 if (arg5 == NULL) SWIG_fail;
39313 temp5 = true;
39314 }
39315 }
39316 {
39317 PyThreadState* __tstate = wxPyBeginAllowThreads();
39318 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39319 wxPyEndAllowThreads(__tstate);
39320 if (PyErr_Occurred()) SWIG_fail;
39321 }
39322 {
39323 resultobj = wxPyMake_wxObject(result, (bool)0);
39324 }
39325 {
39326 if (temp4)
39327 delete arg4;
39328 }
39329 {
39330 if (temp5)
39331 delete arg5;
39332 }
39333 return resultobj;
39334 fail:
39335 {
39336 if (temp4)
39337 delete arg4;
39338 }
39339 {
39340 if (temp5)
39341 delete arg5;
39342 }
39343 return NULL;
39344 }
39345
39346
39347 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39348 PyObject *resultobj = 0;
39349 wxMenu *arg1 = (wxMenu *) 0 ;
39350 size_t arg2 ;
39351 int arg3 ;
39352 wxString *arg4 = 0 ;
39353 wxString const &arg5_defvalue = wxPyEmptyString ;
39354 wxString *arg5 = (wxString *) &arg5_defvalue ;
39355 wxMenuItem *result = 0 ;
39356 void *argp1 = 0 ;
39357 int res1 = 0 ;
39358 size_t val2 ;
39359 int ecode2 = 0 ;
39360 int val3 ;
39361 int ecode3 = 0 ;
39362 bool temp4 = false ;
39363 bool temp5 = false ;
39364 PyObject * obj0 = 0 ;
39365 PyObject * obj1 = 0 ;
39366 PyObject * obj2 = 0 ;
39367 PyObject * obj3 = 0 ;
39368 PyObject * obj4 = 0 ;
39369 char * kwnames[] = {
39370 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39371 };
39372
39373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39375 if (!SWIG_IsOK(res1)) {
39376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39377 }
39378 arg1 = reinterpret_cast< wxMenu * >(argp1);
39379 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39380 if (!SWIG_IsOK(ecode2)) {
39381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39382 }
39383 arg2 = static_cast< size_t >(val2);
39384 ecode3 = SWIG_AsVal_int(obj2, &val3);
39385 if (!SWIG_IsOK(ecode3)) {
39386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39387 }
39388 arg3 = static_cast< int >(val3);
39389 {
39390 arg4 = wxString_in_helper(obj3);
39391 if (arg4 == NULL) SWIG_fail;
39392 temp4 = true;
39393 }
39394 if (obj4) {
39395 {
39396 arg5 = wxString_in_helper(obj4);
39397 if (arg5 == NULL) SWIG_fail;
39398 temp5 = true;
39399 }
39400 }
39401 {
39402 PyThreadState* __tstate = wxPyBeginAllowThreads();
39403 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39404 wxPyEndAllowThreads(__tstate);
39405 if (PyErr_Occurred()) SWIG_fail;
39406 }
39407 {
39408 resultobj = wxPyMake_wxObject(result, (bool)0);
39409 }
39410 {
39411 if (temp4)
39412 delete arg4;
39413 }
39414 {
39415 if (temp5)
39416 delete arg5;
39417 }
39418 return resultobj;
39419 fail:
39420 {
39421 if (temp4)
39422 delete arg4;
39423 }
39424 {
39425 if (temp5)
39426 delete arg5;
39427 }
39428 return NULL;
39429 }
39430
39431
39432 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39433 PyObject *resultobj = 0;
39434 wxMenu *arg1 = (wxMenu *) 0 ;
39435 size_t arg2 ;
39436 int arg3 ;
39437 wxString *arg4 = 0 ;
39438 wxMenu *arg5 = (wxMenu *) 0 ;
39439 wxString const &arg6_defvalue = wxPyEmptyString ;
39440 wxString *arg6 = (wxString *) &arg6_defvalue ;
39441 wxMenuItem *result = 0 ;
39442 void *argp1 = 0 ;
39443 int res1 = 0 ;
39444 size_t val2 ;
39445 int ecode2 = 0 ;
39446 int val3 ;
39447 int ecode3 = 0 ;
39448 bool temp4 = false ;
39449 void *argp5 = 0 ;
39450 int res5 = 0 ;
39451 bool temp6 = false ;
39452 PyObject * obj0 = 0 ;
39453 PyObject * obj1 = 0 ;
39454 PyObject * obj2 = 0 ;
39455 PyObject * obj3 = 0 ;
39456 PyObject * obj4 = 0 ;
39457 PyObject * obj5 = 0 ;
39458 char * kwnames[] = {
39459 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39460 };
39461
39462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39464 if (!SWIG_IsOK(res1)) {
39465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39466 }
39467 arg1 = reinterpret_cast< wxMenu * >(argp1);
39468 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39469 if (!SWIG_IsOK(ecode2)) {
39470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39471 }
39472 arg2 = static_cast< size_t >(val2);
39473 ecode3 = SWIG_AsVal_int(obj2, &val3);
39474 if (!SWIG_IsOK(ecode3)) {
39475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39476 }
39477 arg3 = static_cast< int >(val3);
39478 {
39479 arg4 = wxString_in_helper(obj3);
39480 if (arg4 == NULL) SWIG_fail;
39481 temp4 = true;
39482 }
39483 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39484 if (!SWIG_IsOK(res5)) {
39485 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39486 }
39487 arg5 = reinterpret_cast< wxMenu * >(argp5);
39488 if (obj5) {
39489 {
39490 arg6 = wxString_in_helper(obj5);
39491 if (arg6 == NULL) SWIG_fail;
39492 temp6 = true;
39493 }
39494 }
39495 {
39496 PyThreadState* __tstate = wxPyBeginAllowThreads();
39497 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39498 wxPyEndAllowThreads(__tstate);
39499 if (PyErr_Occurred()) SWIG_fail;
39500 }
39501 {
39502 resultobj = wxPyMake_wxObject(result, (bool)0);
39503 }
39504 {
39505 if (temp4)
39506 delete arg4;
39507 }
39508 {
39509 if (temp6)
39510 delete arg6;
39511 }
39512 return resultobj;
39513 fail:
39514 {
39515 if (temp4)
39516 delete arg4;
39517 }
39518 {
39519 if (temp6)
39520 delete arg6;
39521 }
39522 return NULL;
39523 }
39524
39525
39526 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39527 PyObject *resultobj = 0;
39528 wxMenu *arg1 = (wxMenu *) 0 ;
39529 int arg2 ;
39530 wxString *arg3 = 0 ;
39531 wxString const &arg4_defvalue = wxPyEmptyString ;
39532 wxString *arg4 = (wxString *) &arg4_defvalue ;
39533 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39534 wxMenuItem *result = 0 ;
39535 void *argp1 = 0 ;
39536 int res1 = 0 ;
39537 int val2 ;
39538 int ecode2 = 0 ;
39539 bool temp3 = false ;
39540 bool temp4 = false ;
39541 int val5 ;
39542 int ecode5 = 0 ;
39543 PyObject * obj0 = 0 ;
39544 PyObject * obj1 = 0 ;
39545 PyObject * obj2 = 0 ;
39546 PyObject * obj3 = 0 ;
39547 PyObject * obj4 = 0 ;
39548 char * kwnames[] = {
39549 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39550 };
39551
39552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39554 if (!SWIG_IsOK(res1)) {
39555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39556 }
39557 arg1 = reinterpret_cast< wxMenu * >(argp1);
39558 ecode2 = SWIG_AsVal_int(obj1, &val2);
39559 if (!SWIG_IsOK(ecode2)) {
39560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39561 }
39562 arg2 = static_cast< int >(val2);
39563 {
39564 arg3 = wxString_in_helper(obj2);
39565 if (arg3 == NULL) SWIG_fail;
39566 temp3 = true;
39567 }
39568 if (obj3) {
39569 {
39570 arg4 = wxString_in_helper(obj3);
39571 if (arg4 == NULL) SWIG_fail;
39572 temp4 = true;
39573 }
39574 }
39575 if (obj4) {
39576 ecode5 = SWIG_AsVal_int(obj4, &val5);
39577 if (!SWIG_IsOK(ecode5)) {
39578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39579 }
39580 arg5 = static_cast< wxItemKind >(val5);
39581 }
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39585 wxPyEndAllowThreads(__tstate);
39586 if (PyErr_Occurred()) SWIG_fail;
39587 }
39588 {
39589 resultobj = wxPyMake_wxObject(result, (bool)0);
39590 }
39591 {
39592 if (temp3)
39593 delete arg3;
39594 }
39595 {
39596 if (temp4)
39597 delete arg4;
39598 }
39599 return resultobj;
39600 fail:
39601 {
39602 if (temp3)
39603 delete arg3;
39604 }
39605 {
39606 if (temp4)
39607 delete arg4;
39608 }
39609 return NULL;
39610 }
39611
39612
39613 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39614 PyObject *resultobj = 0;
39615 wxMenu *arg1 = (wxMenu *) 0 ;
39616 wxMenuItem *result = 0 ;
39617 void *argp1 = 0 ;
39618 int res1 = 0 ;
39619 PyObject *swig_obj[1] ;
39620
39621 if (!args) SWIG_fail;
39622 swig_obj[0] = args;
39623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39624 if (!SWIG_IsOK(res1)) {
39625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39626 }
39627 arg1 = reinterpret_cast< wxMenu * >(argp1);
39628 {
39629 PyThreadState* __tstate = wxPyBeginAllowThreads();
39630 result = (wxMenuItem *)(arg1)->PrependSeparator();
39631 wxPyEndAllowThreads(__tstate);
39632 if (PyErr_Occurred()) SWIG_fail;
39633 }
39634 {
39635 resultobj = wxPyMake_wxObject(result, (bool)0);
39636 }
39637 return resultobj;
39638 fail:
39639 return NULL;
39640 }
39641
39642
39643 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39644 PyObject *resultobj = 0;
39645 wxMenu *arg1 = (wxMenu *) 0 ;
39646 int arg2 ;
39647 wxString *arg3 = 0 ;
39648 wxString const &arg4_defvalue = wxPyEmptyString ;
39649 wxString *arg4 = (wxString *) &arg4_defvalue ;
39650 wxMenuItem *result = 0 ;
39651 void *argp1 = 0 ;
39652 int res1 = 0 ;
39653 int val2 ;
39654 int ecode2 = 0 ;
39655 bool temp3 = false ;
39656 bool temp4 = false ;
39657 PyObject * obj0 = 0 ;
39658 PyObject * obj1 = 0 ;
39659 PyObject * obj2 = 0 ;
39660 PyObject * obj3 = 0 ;
39661 char * kwnames[] = {
39662 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39663 };
39664
39665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39667 if (!SWIG_IsOK(res1)) {
39668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39669 }
39670 arg1 = reinterpret_cast< wxMenu * >(argp1);
39671 ecode2 = SWIG_AsVal_int(obj1, &val2);
39672 if (!SWIG_IsOK(ecode2)) {
39673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39674 }
39675 arg2 = static_cast< int >(val2);
39676 {
39677 arg3 = wxString_in_helper(obj2);
39678 if (arg3 == NULL) SWIG_fail;
39679 temp3 = true;
39680 }
39681 if (obj3) {
39682 {
39683 arg4 = wxString_in_helper(obj3);
39684 if (arg4 == NULL) SWIG_fail;
39685 temp4 = true;
39686 }
39687 }
39688 {
39689 PyThreadState* __tstate = wxPyBeginAllowThreads();
39690 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39691 wxPyEndAllowThreads(__tstate);
39692 if (PyErr_Occurred()) SWIG_fail;
39693 }
39694 {
39695 resultobj = wxPyMake_wxObject(result, (bool)0);
39696 }
39697 {
39698 if (temp3)
39699 delete arg3;
39700 }
39701 {
39702 if (temp4)
39703 delete arg4;
39704 }
39705 return resultobj;
39706 fail:
39707 {
39708 if (temp3)
39709 delete arg3;
39710 }
39711 {
39712 if (temp4)
39713 delete arg4;
39714 }
39715 return NULL;
39716 }
39717
39718
39719 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39720 PyObject *resultobj = 0;
39721 wxMenu *arg1 = (wxMenu *) 0 ;
39722 int arg2 ;
39723 wxString *arg3 = 0 ;
39724 wxString const &arg4_defvalue = wxPyEmptyString ;
39725 wxString *arg4 = (wxString *) &arg4_defvalue ;
39726 wxMenuItem *result = 0 ;
39727 void *argp1 = 0 ;
39728 int res1 = 0 ;
39729 int val2 ;
39730 int ecode2 = 0 ;
39731 bool temp3 = false ;
39732 bool temp4 = false ;
39733 PyObject * obj0 = 0 ;
39734 PyObject * obj1 = 0 ;
39735 PyObject * obj2 = 0 ;
39736 PyObject * obj3 = 0 ;
39737 char * kwnames[] = {
39738 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39739 };
39740
39741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39743 if (!SWIG_IsOK(res1)) {
39744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39745 }
39746 arg1 = reinterpret_cast< wxMenu * >(argp1);
39747 ecode2 = SWIG_AsVal_int(obj1, &val2);
39748 if (!SWIG_IsOK(ecode2)) {
39749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39750 }
39751 arg2 = static_cast< int >(val2);
39752 {
39753 arg3 = wxString_in_helper(obj2);
39754 if (arg3 == NULL) SWIG_fail;
39755 temp3 = true;
39756 }
39757 if (obj3) {
39758 {
39759 arg4 = wxString_in_helper(obj3);
39760 if (arg4 == NULL) SWIG_fail;
39761 temp4 = true;
39762 }
39763 }
39764 {
39765 PyThreadState* __tstate = wxPyBeginAllowThreads();
39766 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 {
39771 resultobj = wxPyMake_wxObject(result, (bool)0);
39772 }
39773 {
39774 if (temp3)
39775 delete arg3;
39776 }
39777 {
39778 if (temp4)
39779 delete arg4;
39780 }
39781 return resultobj;
39782 fail:
39783 {
39784 if (temp3)
39785 delete arg3;
39786 }
39787 {
39788 if (temp4)
39789 delete arg4;
39790 }
39791 return NULL;
39792 }
39793
39794
39795 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39796 PyObject *resultobj = 0;
39797 wxMenu *arg1 = (wxMenu *) 0 ;
39798 int arg2 ;
39799 wxString *arg3 = 0 ;
39800 wxMenu *arg4 = (wxMenu *) 0 ;
39801 wxString const &arg5_defvalue = wxPyEmptyString ;
39802 wxString *arg5 = (wxString *) &arg5_defvalue ;
39803 wxMenuItem *result = 0 ;
39804 void *argp1 = 0 ;
39805 int res1 = 0 ;
39806 int val2 ;
39807 int ecode2 = 0 ;
39808 bool temp3 = false ;
39809 void *argp4 = 0 ;
39810 int res4 = 0 ;
39811 bool temp5 = false ;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 PyObject * obj2 = 0 ;
39815 PyObject * obj3 = 0 ;
39816 PyObject * obj4 = 0 ;
39817 char * kwnames[] = {
39818 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39819 };
39820
39821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39823 if (!SWIG_IsOK(res1)) {
39824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39825 }
39826 arg1 = reinterpret_cast< wxMenu * >(argp1);
39827 ecode2 = SWIG_AsVal_int(obj1, &val2);
39828 if (!SWIG_IsOK(ecode2)) {
39829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39830 }
39831 arg2 = static_cast< int >(val2);
39832 {
39833 arg3 = wxString_in_helper(obj2);
39834 if (arg3 == NULL) SWIG_fail;
39835 temp3 = true;
39836 }
39837 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39838 if (!SWIG_IsOK(res4)) {
39839 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39840 }
39841 arg4 = reinterpret_cast< wxMenu * >(argp4);
39842 if (obj4) {
39843 {
39844 arg5 = wxString_in_helper(obj4);
39845 if (arg5 == NULL) SWIG_fail;
39846 temp5 = true;
39847 }
39848 }
39849 {
39850 PyThreadState* __tstate = wxPyBeginAllowThreads();
39851 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39852 wxPyEndAllowThreads(__tstate);
39853 if (PyErr_Occurred()) SWIG_fail;
39854 }
39855 {
39856 resultobj = wxPyMake_wxObject(result, (bool)0);
39857 }
39858 {
39859 if (temp3)
39860 delete arg3;
39861 }
39862 {
39863 if (temp5)
39864 delete arg5;
39865 }
39866 return resultobj;
39867 fail:
39868 {
39869 if (temp3)
39870 delete arg3;
39871 }
39872 {
39873 if (temp5)
39874 delete arg5;
39875 }
39876 return NULL;
39877 }
39878
39879
39880 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39881 PyObject *resultobj = 0;
39882 wxMenu *arg1 = (wxMenu *) 0 ;
39883 int arg2 ;
39884 wxMenuItem *result = 0 ;
39885 void *argp1 = 0 ;
39886 int res1 = 0 ;
39887 int val2 ;
39888 int ecode2 = 0 ;
39889 PyObject * obj0 = 0 ;
39890 PyObject * obj1 = 0 ;
39891 char * kwnames[] = {
39892 (char *) "self",(char *) "id", NULL
39893 };
39894
39895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39897 if (!SWIG_IsOK(res1)) {
39898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39899 }
39900 arg1 = reinterpret_cast< wxMenu * >(argp1);
39901 ecode2 = SWIG_AsVal_int(obj1, &val2);
39902 if (!SWIG_IsOK(ecode2)) {
39903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39904 }
39905 arg2 = static_cast< int >(val2);
39906 {
39907 PyThreadState* __tstate = wxPyBeginAllowThreads();
39908 result = (wxMenuItem *)(arg1)->Remove(arg2);
39909 wxPyEndAllowThreads(__tstate);
39910 if (PyErr_Occurred()) SWIG_fail;
39911 }
39912 {
39913 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39914 }
39915 return resultobj;
39916 fail:
39917 return NULL;
39918 }
39919
39920
39921 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39922 PyObject *resultobj = 0;
39923 wxMenu *arg1 = (wxMenu *) 0 ;
39924 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39925 wxMenuItem *result = 0 ;
39926 void *argp1 = 0 ;
39927 int res1 = 0 ;
39928 void *argp2 = 0 ;
39929 int res2 = 0 ;
39930 PyObject * obj0 = 0 ;
39931 PyObject * obj1 = 0 ;
39932 char * kwnames[] = {
39933 (char *) "self",(char *) "item", NULL
39934 };
39935
39936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39938 if (!SWIG_IsOK(res1)) {
39939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39940 }
39941 arg1 = reinterpret_cast< wxMenu * >(argp1);
39942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39943 if (!SWIG_IsOK(res2)) {
39944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39945 }
39946 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 result = (wxMenuItem *)(arg1)->Remove(arg2);
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 {
39954 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39955 }
39956 return resultobj;
39957 fail:
39958 return NULL;
39959 }
39960
39961
39962 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39963 PyObject *resultobj = 0;
39964 wxMenu *arg1 = (wxMenu *) 0 ;
39965 int arg2 ;
39966 bool result;
39967 void *argp1 = 0 ;
39968 int res1 = 0 ;
39969 int val2 ;
39970 int ecode2 = 0 ;
39971 PyObject * obj0 = 0 ;
39972 PyObject * obj1 = 0 ;
39973 char * kwnames[] = {
39974 (char *) "self",(char *) "id", NULL
39975 };
39976
39977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39979 if (!SWIG_IsOK(res1)) {
39980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39981 }
39982 arg1 = reinterpret_cast< wxMenu * >(argp1);
39983 ecode2 = SWIG_AsVal_int(obj1, &val2);
39984 if (!SWIG_IsOK(ecode2)) {
39985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39986 }
39987 arg2 = static_cast< int >(val2);
39988 {
39989 PyThreadState* __tstate = wxPyBeginAllowThreads();
39990 result = (bool)(arg1)->Delete(arg2);
39991 wxPyEndAllowThreads(__tstate);
39992 if (PyErr_Occurred()) SWIG_fail;
39993 }
39994 {
39995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39996 }
39997 return resultobj;
39998 fail:
39999 return NULL;
40000 }
40001
40002
40003 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40004 PyObject *resultobj = 0;
40005 wxMenu *arg1 = (wxMenu *) 0 ;
40006 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40007 bool result;
40008 void *argp1 = 0 ;
40009 int res1 = 0 ;
40010 void *argp2 = 0 ;
40011 int res2 = 0 ;
40012 PyObject * obj0 = 0 ;
40013 PyObject * obj1 = 0 ;
40014 char * kwnames[] = {
40015 (char *) "self",(char *) "item", NULL
40016 };
40017
40018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40020 if (!SWIG_IsOK(res1)) {
40021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40022 }
40023 arg1 = reinterpret_cast< wxMenu * >(argp1);
40024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40025 if (!SWIG_IsOK(res2)) {
40026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40027 }
40028 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40029 {
40030 PyThreadState* __tstate = wxPyBeginAllowThreads();
40031 result = (bool)(arg1)->Delete(arg2);
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 {
40036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40037 }
40038 return resultobj;
40039 fail:
40040 return NULL;
40041 }
40042
40043
40044 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40045 PyObject *resultobj = 0;
40046 wxMenu *arg1 = (wxMenu *) 0 ;
40047 void *argp1 = 0 ;
40048 int res1 = 0 ;
40049 PyObject *swig_obj[1] ;
40050
40051 if (!args) SWIG_fail;
40052 swig_obj[0] = args;
40053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40054 if (!SWIG_IsOK(res1)) {
40055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40056 }
40057 arg1 = reinterpret_cast< wxMenu * >(argp1);
40058 {
40059 PyThreadState* __tstate = wxPyBeginAllowThreads();
40060 wxMenu_Destroy(arg1);
40061 wxPyEndAllowThreads(__tstate);
40062 if (PyErr_Occurred()) SWIG_fail;
40063 }
40064 resultobj = SWIG_Py_Void();
40065 return resultobj;
40066 fail:
40067 return NULL;
40068 }
40069
40070
40071 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40072 PyObject *resultobj = 0;
40073 wxMenu *arg1 = (wxMenu *) 0 ;
40074 int arg2 ;
40075 bool result;
40076 void *argp1 = 0 ;
40077 int res1 = 0 ;
40078 int val2 ;
40079 int ecode2 = 0 ;
40080 PyObject * obj0 = 0 ;
40081 PyObject * obj1 = 0 ;
40082 char * kwnames[] = {
40083 (char *) "self",(char *) "id", NULL
40084 };
40085
40086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",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_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40090 }
40091 arg1 = reinterpret_cast< wxMenu * >(argp1);
40092 ecode2 = SWIG_AsVal_int(obj1, &val2);
40093 if (!SWIG_IsOK(ecode2)) {
40094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40095 }
40096 arg2 = static_cast< int >(val2);
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (bool)(arg1)->Destroy(arg2);
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj = 0;
40114 wxMenu *arg1 = (wxMenu *) 0 ;
40115 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40116 bool result;
40117 void *argp1 = 0 ;
40118 int res1 = 0 ;
40119 void *argp2 = 0 ;
40120 int res2 = 0 ;
40121 PyObject * obj0 = 0 ;
40122 PyObject * obj1 = 0 ;
40123 char * kwnames[] = {
40124 (char *) "self",(char *) "item", NULL
40125 };
40126
40127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40129 if (!SWIG_IsOK(res1)) {
40130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40131 }
40132 arg1 = reinterpret_cast< wxMenu * >(argp1);
40133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40134 if (!SWIG_IsOK(res2)) {
40135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40136 }
40137 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 result = (bool)(arg1)->Destroy(arg2);
40141 wxPyEndAllowThreads(__tstate);
40142 if (PyErr_Occurred()) SWIG_fail;
40143 }
40144 {
40145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40146 }
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40154 PyObject *resultobj = 0;
40155 wxMenu *arg1 = (wxMenu *) 0 ;
40156 size_t result;
40157 void *argp1 = 0 ;
40158 int res1 = 0 ;
40159 PyObject *swig_obj[1] ;
40160
40161 if (!args) SWIG_fail;
40162 swig_obj[0] = args;
40163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40164 if (!SWIG_IsOK(res1)) {
40165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40166 }
40167 arg1 = reinterpret_cast< wxMenu * >(argp1);
40168 {
40169 PyThreadState* __tstate = wxPyBeginAllowThreads();
40170 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40171 wxPyEndAllowThreads(__tstate);
40172 if (PyErr_Occurred()) SWIG_fail;
40173 }
40174 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40175 return resultobj;
40176 fail:
40177 return NULL;
40178 }
40179
40180
40181 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40182 PyObject *resultobj = 0;
40183 wxMenu *arg1 = (wxMenu *) 0 ;
40184 PyObject *result = 0 ;
40185 void *argp1 = 0 ;
40186 int res1 = 0 ;
40187 PyObject *swig_obj[1] ;
40188
40189 if (!args) SWIG_fail;
40190 swig_obj[0] = args;
40191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40192 if (!SWIG_IsOK(res1)) {
40193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40194 }
40195 arg1 = reinterpret_cast< wxMenu * >(argp1);
40196 {
40197 PyThreadState* __tstate = wxPyBeginAllowThreads();
40198 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40199 wxPyEndAllowThreads(__tstate);
40200 if (PyErr_Occurred()) SWIG_fail;
40201 }
40202 resultobj = result;
40203 return resultobj;
40204 fail:
40205 return NULL;
40206 }
40207
40208
40209 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40210 PyObject *resultobj = 0;
40211 wxMenu *arg1 = (wxMenu *) 0 ;
40212 wxString *arg2 = 0 ;
40213 int result;
40214 void *argp1 = 0 ;
40215 int res1 = 0 ;
40216 bool temp2 = false ;
40217 PyObject * obj0 = 0 ;
40218 PyObject * obj1 = 0 ;
40219 char * kwnames[] = {
40220 (char *) "self",(char *) "item", NULL
40221 };
40222
40223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40225 if (!SWIG_IsOK(res1)) {
40226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40227 }
40228 arg1 = reinterpret_cast< wxMenu * >(argp1);
40229 {
40230 arg2 = wxString_in_helper(obj1);
40231 if (arg2 == NULL) SWIG_fail;
40232 temp2 = true;
40233 }
40234 {
40235 PyThreadState* __tstate = wxPyBeginAllowThreads();
40236 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 resultobj = SWIG_From_int(static_cast< int >(result));
40241 {
40242 if (temp2)
40243 delete arg2;
40244 }
40245 return resultobj;
40246 fail:
40247 {
40248 if (temp2)
40249 delete arg2;
40250 }
40251 return NULL;
40252 }
40253
40254
40255 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj = 0;
40257 wxMenu *arg1 = (wxMenu *) 0 ;
40258 int arg2 ;
40259 wxMenuItem *result = 0 ;
40260 void *argp1 = 0 ;
40261 int res1 = 0 ;
40262 int val2 ;
40263 int ecode2 = 0 ;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 char * kwnames[] = {
40267 (char *) "self",(char *) "id", NULL
40268 };
40269
40270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40272 if (!SWIG_IsOK(res1)) {
40273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40274 }
40275 arg1 = reinterpret_cast< wxMenu * >(argp1);
40276 ecode2 = SWIG_AsVal_int(obj1, &val2);
40277 if (!SWIG_IsOK(ecode2)) {
40278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40279 }
40280 arg2 = static_cast< int >(val2);
40281 {
40282 PyThreadState* __tstate = wxPyBeginAllowThreads();
40283 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40284 wxPyEndAllowThreads(__tstate);
40285 if (PyErr_Occurred()) SWIG_fail;
40286 }
40287 {
40288 resultobj = wxPyMake_wxObject(result, (bool)0);
40289 }
40290 return resultobj;
40291 fail:
40292 return NULL;
40293 }
40294
40295
40296 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40297 PyObject *resultobj = 0;
40298 wxMenu *arg1 = (wxMenu *) 0 ;
40299 size_t arg2 ;
40300 wxMenuItem *result = 0 ;
40301 void *argp1 = 0 ;
40302 int res1 = 0 ;
40303 size_t val2 ;
40304 int ecode2 = 0 ;
40305 PyObject * obj0 = 0 ;
40306 PyObject * obj1 = 0 ;
40307 char * kwnames[] = {
40308 (char *) "self",(char *) "position", NULL
40309 };
40310
40311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40313 if (!SWIG_IsOK(res1)) {
40314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40315 }
40316 arg1 = reinterpret_cast< wxMenu * >(argp1);
40317 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40318 if (!SWIG_IsOK(ecode2)) {
40319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40320 }
40321 arg2 = static_cast< size_t >(val2);
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40325 wxPyEndAllowThreads(__tstate);
40326 if (PyErr_Occurred()) SWIG_fail;
40327 }
40328 {
40329 resultobj = wxPyMake_wxObject(result, (bool)0);
40330 }
40331 return resultobj;
40332 fail:
40333 return NULL;
40334 }
40335
40336
40337 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40338 PyObject *resultobj = 0;
40339 wxMenu *arg1 = (wxMenu *) 0 ;
40340 int arg2 ;
40341 bool arg3 ;
40342 void *argp1 = 0 ;
40343 int res1 = 0 ;
40344 int val2 ;
40345 int ecode2 = 0 ;
40346 bool val3 ;
40347 int ecode3 = 0 ;
40348 PyObject * obj0 = 0 ;
40349 PyObject * obj1 = 0 ;
40350 PyObject * obj2 = 0 ;
40351 char * kwnames[] = {
40352 (char *) "self",(char *) "id",(char *) "enable", NULL
40353 };
40354
40355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40357 if (!SWIG_IsOK(res1)) {
40358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40359 }
40360 arg1 = reinterpret_cast< wxMenu * >(argp1);
40361 ecode2 = SWIG_AsVal_int(obj1, &val2);
40362 if (!SWIG_IsOK(ecode2)) {
40363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40364 }
40365 arg2 = static_cast< int >(val2);
40366 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40367 if (!SWIG_IsOK(ecode3)) {
40368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40369 }
40370 arg3 = static_cast< bool >(val3);
40371 {
40372 PyThreadState* __tstate = wxPyBeginAllowThreads();
40373 (arg1)->Enable(arg2,arg3);
40374 wxPyEndAllowThreads(__tstate);
40375 if (PyErr_Occurred()) SWIG_fail;
40376 }
40377 resultobj = SWIG_Py_Void();
40378 return resultobj;
40379 fail:
40380 return NULL;
40381 }
40382
40383
40384 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40385 PyObject *resultobj = 0;
40386 wxMenu *arg1 = (wxMenu *) 0 ;
40387 int arg2 ;
40388 bool result;
40389 void *argp1 = 0 ;
40390 int res1 = 0 ;
40391 int val2 ;
40392 int ecode2 = 0 ;
40393 PyObject * obj0 = 0 ;
40394 PyObject * obj1 = 0 ;
40395 char * kwnames[] = {
40396 (char *) "self",(char *) "id", NULL
40397 };
40398
40399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40401 if (!SWIG_IsOK(res1)) {
40402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40403 }
40404 arg1 = reinterpret_cast< wxMenu * >(argp1);
40405 ecode2 = SWIG_AsVal_int(obj1, &val2);
40406 if (!SWIG_IsOK(ecode2)) {
40407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40408 }
40409 arg2 = static_cast< int >(val2);
40410 {
40411 PyThreadState* __tstate = wxPyBeginAllowThreads();
40412 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40413 wxPyEndAllowThreads(__tstate);
40414 if (PyErr_Occurred()) SWIG_fail;
40415 }
40416 {
40417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40418 }
40419 return resultobj;
40420 fail:
40421 return NULL;
40422 }
40423
40424
40425 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj = 0;
40427 wxMenu *arg1 = (wxMenu *) 0 ;
40428 int arg2 ;
40429 bool arg3 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 int val2 ;
40433 int ecode2 = 0 ;
40434 bool val3 ;
40435 int ecode3 = 0 ;
40436 PyObject * obj0 = 0 ;
40437 PyObject * obj1 = 0 ;
40438 PyObject * obj2 = 0 ;
40439 char * kwnames[] = {
40440 (char *) "self",(char *) "id",(char *) "check", NULL
40441 };
40442
40443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40445 if (!SWIG_IsOK(res1)) {
40446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40447 }
40448 arg1 = reinterpret_cast< wxMenu * >(argp1);
40449 ecode2 = SWIG_AsVal_int(obj1, &val2);
40450 if (!SWIG_IsOK(ecode2)) {
40451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40452 }
40453 arg2 = static_cast< int >(val2);
40454 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40455 if (!SWIG_IsOK(ecode3)) {
40456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40457 }
40458 arg3 = static_cast< bool >(val3);
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 (arg1)->Check(arg2,arg3);
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 resultobj = SWIG_Py_Void();
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40473 PyObject *resultobj = 0;
40474 wxMenu *arg1 = (wxMenu *) 0 ;
40475 int arg2 ;
40476 bool result;
40477 void *argp1 = 0 ;
40478 int res1 = 0 ;
40479 int val2 ;
40480 int ecode2 = 0 ;
40481 PyObject * obj0 = 0 ;
40482 PyObject * obj1 = 0 ;
40483 char * kwnames[] = {
40484 (char *) "self",(char *) "id", NULL
40485 };
40486
40487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40489 if (!SWIG_IsOK(res1)) {
40490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40491 }
40492 arg1 = reinterpret_cast< wxMenu * >(argp1);
40493 ecode2 = SWIG_AsVal_int(obj1, &val2);
40494 if (!SWIG_IsOK(ecode2)) {
40495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40496 }
40497 arg2 = static_cast< int >(val2);
40498 {
40499 PyThreadState* __tstate = wxPyBeginAllowThreads();
40500 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40501 wxPyEndAllowThreads(__tstate);
40502 if (PyErr_Occurred()) SWIG_fail;
40503 }
40504 {
40505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40506 }
40507 return resultobj;
40508 fail:
40509 return NULL;
40510 }
40511
40512
40513 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40514 PyObject *resultobj = 0;
40515 wxMenu *arg1 = (wxMenu *) 0 ;
40516 int arg2 ;
40517 wxString *arg3 = 0 ;
40518 void *argp1 = 0 ;
40519 int res1 = 0 ;
40520 int val2 ;
40521 int ecode2 = 0 ;
40522 bool temp3 = false ;
40523 PyObject * obj0 = 0 ;
40524 PyObject * obj1 = 0 ;
40525 PyObject * obj2 = 0 ;
40526 char * kwnames[] = {
40527 (char *) "self",(char *) "id",(char *) "label", NULL
40528 };
40529
40530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40532 if (!SWIG_IsOK(res1)) {
40533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40534 }
40535 arg1 = reinterpret_cast< wxMenu * >(argp1);
40536 ecode2 = SWIG_AsVal_int(obj1, &val2);
40537 if (!SWIG_IsOK(ecode2)) {
40538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40539 }
40540 arg2 = static_cast< int >(val2);
40541 {
40542 arg3 = wxString_in_helper(obj2);
40543 if (arg3 == NULL) SWIG_fail;
40544 temp3 = true;
40545 }
40546 {
40547 PyThreadState* __tstate = wxPyBeginAllowThreads();
40548 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 resultobj = SWIG_Py_Void();
40553 {
40554 if (temp3)
40555 delete arg3;
40556 }
40557 return resultobj;
40558 fail:
40559 {
40560 if (temp3)
40561 delete arg3;
40562 }
40563 return NULL;
40564 }
40565
40566
40567 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40568 PyObject *resultobj = 0;
40569 wxMenu *arg1 = (wxMenu *) 0 ;
40570 int arg2 ;
40571 wxString result;
40572 void *argp1 = 0 ;
40573 int res1 = 0 ;
40574 int val2 ;
40575 int ecode2 = 0 ;
40576 PyObject * obj0 = 0 ;
40577 PyObject * obj1 = 0 ;
40578 char * kwnames[] = {
40579 (char *) "self",(char *) "id", NULL
40580 };
40581
40582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40584 if (!SWIG_IsOK(res1)) {
40585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40586 }
40587 arg1 = reinterpret_cast< wxMenu * >(argp1);
40588 ecode2 = SWIG_AsVal_int(obj1, &val2);
40589 if (!SWIG_IsOK(ecode2)) {
40590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40591 }
40592 arg2 = static_cast< int >(val2);
40593 {
40594 PyThreadState* __tstate = wxPyBeginAllowThreads();
40595 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40596 wxPyEndAllowThreads(__tstate);
40597 if (PyErr_Occurred()) SWIG_fail;
40598 }
40599 {
40600 #if wxUSE_UNICODE
40601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40602 #else
40603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40604 #endif
40605 }
40606 return resultobj;
40607 fail:
40608 return NULL;
40609 }
40610
40611
40612 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40613 PyObject *resultobj = 0;
40614 wxMenu *arg1 = (wxMenu *) 0 ;
40615 int arg2 ;
40616 wxString *arg3 = 0 ;
40617 void *argp1 = 0 ;
40618 int res1 = 0 ;
40619 int val2 ;
40620 int ecode2 = 0 ;
40621 bool temp3 = false ;
40622 PyObject * obj0 = 0 ;
40623 PyObject * obj1 = 0 ;
40624 PyObject * obj2 = 0 ;
40625 char * kwnames[] = {
40626 (char *) "self",(char *) "id",(char *) "helpString", NULL
40627 };
40628
40629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40631 if (!SWIG_IsOK(res1)) {
40632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40633 }
40634 arg1 = reinterpret_cast< wxMenu * >(argp1);
40635 ecode2 = SWIG_AsVal_int(obj1, &val2);
40636 if (!SWIG_IsOK(ecode2)) {
40637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40638 }
40639 arg2 = static_cast< int >(val2);
40640 {
40641 arg3 = wxString_in_helper(obj2);
40642 if (arg3 == NULL) SWIG_fail;
40643 temp3 = true;
40644 }
40645 {
40646 PyThreadState* __tstate = wxPyBeginAllowThreads();
40647 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40648 wxPyEndAllowThreads(__tstate);
40649 if (PyErr_Occurred()) SWIG_fail;
40650 }
40651 resultobj = SWIG_Py_Void();
40652 {
40653 if (temp3)
40654 delete arg3;
40655 }
40656 return resultobj;
40657 fail:
40658 {
40659 if (temp3)
40660 delete arg3;
40661 }
40662 return NULL;
40663 }
40664
40665
40666 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40667 PyObject *resultobj = 0;
40668 wxMenu *arg1 = (wxMenu *) 0 ;
40669 int arg2 ;
40670 wxString result;
40671 void *argp1 = 0 ;
40672 int res1 = 0 ;
40673 int val2 ;
40674 int ecode2 = 0 ;
40675 PyObject * obj0 = 0 ;
40676 PyObject * obj1 = 0 ;
40677 char * kwnames[] = {
40678 (char *) "self",(char *) "id", NULL
40679 };
40680
40681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40683 if (!SWIG_IsOK(res1)) {
40684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40685 }
40686 arg1 = reinterpret_cast< wxMenu * >(argp1);
40687 ecode2 = SWIG_AsVal_int(obj1, &val2);
40688 if (!SWIG_IsOK(ecode2)) {
40689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40690 }
40691 arg2 = static_cast< int >(val2);
40692 {
40693 PyThreadState* __tstate = wxPyBeginAllowThreads();
40694 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40695 wxPyEndAllowThreads(__tstate);
40696 if (PyErr_Occurred()) SWIG_fail;
40697 }
40698 {
40699 #if wxUSE_UNICODE
40700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40701 #else
40702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40703 #endif
40704 }
40705 return resultobj;
40706 fail:
40707 return NULL;
40708 }
40709
40710
40711 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40712 PyObject *resultobj = 0;
40713 wxMenu *arg1 = (wxMenu *) 0 ;
40714 wxString *arg2 = 0 ;
40715 void *argp1 = 0 ;
40716 int res1 = 0 ;
40717 bool temp2 = false ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 char * kwnames[] = {
40721 (char *) "self",(char *) "title", NULL
40722 };
40723
40724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40726 if (!SWIG_IsOK(res1)) {
40727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40728 }
40729 arg1 = reinterpret_cast< wxMenu * >(argp1);
40730 {
40731 arg2 = wxString_in_helper(obj1);
40732 if (arg2 == NULL) SWIG_fail;
40733 temp2 = true;
40734 }
40735 {
40736 PyThreadState* __tstate = wxPyBeginAllowThreads();
40737 (arg1)->SetTitle((wxString const &)*arg2);
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 resultobj = SWIG_Py_Void();
40742 {
40743 if (temp2)
40744 delete arg2;
40745 }
40746 return resultobj;
40747 fail:
40748 {
40749 if (temp2)
40750 delete arg2;
40751 }
40752 return NULL;
40753 }
40754
40755
40756 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40757 PyObject *resultobj = 0;
40758 wxMenu *arg1 = (wxMenu *) 0 ;
40759 wxString result;
40760 void *argp1 = 0 ;
40761 int res1 = 0 ;
40762 PyObject *swig_obj[1] ;
40763
40764 if (!args) SWIG_fail;
40765 swig_obj[0] = args;
40766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40767 if (!SWIG_IsOK(res1)) {
40768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40769 }
40770 arg1 = reinterpret_cast< wxMenu * >(argp1);
40771 {
40772 PyThreadState* __tstate = wxPyBeginAllowThreads();
40773 result = ((wxMenu const *)arg1)->GetTitle();
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 {
40778 #if wxUSE_UNICODE
40779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40780 #else
40781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40782 #endif
40783 }
40784 return resultobj;
40785 fail:
40786 return NULL;
40787 }
40788
40789
40790 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40791 PyObject *resultobj = 0;
40792 wxMenu *arg1 = (wxMenu *) 0 ;
40793 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40794 void *argp1 = 0 ;
40795 int res1 = 0 ;
40796 void *argp2 = 0 ;
40797 int res2 = 0 ;
40798 PyObject * obj0 = 0 ;
40799 PyObject * obj1 = 0 ;
40800 char * kwnames[] = {
40801 (char *) "self",(char *) "handler", NULL
40802 };
40803
40804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40806 if (!SWIG_IsOK(res1)) {
40807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40808 }
40809 arg1 = reinterpret_cast< wxMenu * >(argp1);
40810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40811 if (!SWIG_IsOK(res2)) {
40812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40813 }
40814 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 (arg1)->SetEventHandler(arg2);
40818 wxPyEndAllowThreads(__tstate);
40819 if (PyErr_Occurred()) SWIG_fail;
40820 }
40821 resultobj = SWIG_Py_Void();
40822 return resultobj;
40823 fail:
40824 return NULL;
40825 }
40826
40827
40828 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40829 PyObject *resultobj = 0;
40830 wxMenu *arg1 = (wxMenu *) 0 ;
40831 wxEvtHandler *result = 0 ;
40832 void *argp1 = 0 ;
40833 int res1 = 0 ;
40834 PyObject *swig_obj[1] ;
40835
40836 if (!args) SWIG_fail;
40837 swig_obj[0] = args;
40838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40839 if (!SWIG_IsOK(res1)) {
40840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40841 }
40842 arg1 = reinterpret_cast< wxMenu * >(argp1);
40843 {
40844 PyThreadState* __tstate = wxPyBeginAllowThreads();
40845 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40846 wxPyEndAllowThreads(__tstate);
40847 if (PyErr_Occurred()) SWIG_fail;
40848 }
40849 {
40850 resultobj = wxPyMake_wxObject(result, 0);
40851 }
40852 return resultobj;
40853 fail:
40854 return NULL;
40855 }
40856
40857
40858 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40859 PyObject *resultobj = 0;
40860 wxMenu *arg1 = (wxMenu *) 0 ;
40861 wxWindow *arg2 = (wxWindow *) 0 ;
40862 void *argp1 = 0 ;
40863 int res1 = 0 ;
40864 void *argp2 = 0 ;
40865 int res2 = 0 ;
40866 PyObject * obj0 = 0 ;
40867 PyObject * obj1 = 0 ;
40868 char * kwnames[] = {
40869 (char *) "self",(char *) "win", NULL
40870 };
40871
40872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40874 if (!SWIG_IsOK(res1)) {
40875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40876 }
40877 arg1 = reinterpret_cast< wxMenu * >(argp1);
40878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40879 if (!SWIG_IsOK(res2)) {
40880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40881 }
40882 arg2 = reinterpret_cast< wxWindow * >(argp2);
40883 {
40884 PyThreadState* __tstate = wxPyBeginAllowThreads();
40885 (arg1)->SetInvokingWindow(arg2);
40886 wxPyEndAllowThreads(__tstate);
40887 if (PyErr_Occurred()) SWIG_fail;
40888 }
40889 resultobj = SWIG_Py_Void();
40890 return resultobj;
40891 fail:
40892 return NULL;
40893 }
40894
40895
40896 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40897 PyObject *resultobj = 0;
40898 wxMenu *arg1 = (wxMenu *) 0 ;
40899 wxWindow *result = 0 ;
40900 void *argp1 = 0 ;
40901 int res1 = 0 ;
40902 PyObject *swig_obj[1] ;
40903
40904 if (!args) SWIG_fail;
40905 swig_obj[0] = args;
40906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40907 if (!SWIG_IsOK(res1)) {
40908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40909 }
40910 arg1 = reinterpret_cast< wxMenu * >(argp1);
40911 {
40912 PyThreadState* __tstate = wxPyBeginAllowThreads();
40913 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40914 wxPyEndAllowThreads(__tstate);
40915 if (PyErr_Occurred()) SWIG_fail;
40916 }
40917 {
40918 resultobj = wxPyMake_wxObject(result, 0);
40919 }
40920 return resultobj;
40921 fail:
40922 return NULL;
40923 }
40924
40925
40926 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40927 PyObject *resultobj = 0;
40928 wxMenu *arg1 = (wxMenu *) 0 ;
40929 long result;
40930 void *argp1 = 0 ;
40931 int res1 = 0 ;
40932 PyObject *swig_obj[1] ;
40933
40934 if (!args) SWIG_fail;
40935 swig_obj[0] = args;
40936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40937 if (!SWIG_IsOK(res1)) {
40938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40939 }
40940 arg1 = reinterpret_cast< wxMenu * >(argp1);
40941 {
40942 PyThreadState* __tstate = wxPyBeginAllowThreads();
40943 result = (long)((wxMenu const *)arg1)->GetStyle();
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 resultobj = SWIG_From_long(static_cast< long >(result));
40948 return resultobj;
40949 fail:
40950 return NULL;
40951 }
40952
40953
40954 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40955 PyObject *resultobj = 0;
40956 wxMenu *arg1 = (wxMenu *) 0 ;
40957 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40958 void *argp1 = 0 ;
40959 int res1 = 0 ;
40960 void *argp2 = 0 ;
40961 int res2 = 0 ;
40962 PyObject * obj0 = 0 ;
40963 PyObject * obj1 = 0 ;
40964 char * kwnames[] = {
40965 (char *) "self",(char *) "source", NULL
40966 };
40967
40968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40970 if (!SWIG_IsOK(res1)) {
40971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40972 }
40973 arg1 = reinterpret_cast< wxMenu * >(argp1);
40974 if (obj1) {
40975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40976 if (!SWIG_IsOK(res2)) {
40977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40978 }
40979 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40980 }
40981 {
40982 PyThreadState* __tstate = wxPyBeginAllowThreads();
40983 (arg1)->UpdateUI(arg2);
40984 wxPyEndAllowThreads(__tstate);
40985 if (PyErr_Occurred()) SWIG_fail;
40986 }
40987 resultobj = SWIG_Py_Void();
40988 return resultobj;
40989 fail:
40990 return NULL;
40991 }
40992
40993
40994 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40995 PyObject *resultobj = 0;
40996 wxMenu *arg1 = (wxMenu *) 0 ;
40997 wxMenuBar *result = 0 ;
40998 void *argp1 = 0 ;
40999 int res1 = 0 ;
41000 PyObject *swig_obj[1] ;
41001
41002 if (!args) SWIG_fail;
41003 swig_obj[0] = args;
41004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41005 if (!SWIG_IsOK(res1)) {
41006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41007 }
41008 arg1 = reinterpret_cast< wxMenu * >(argp1);
41009 {
41010 PyThreadState* __tstate = wxPyBeginAllowThreads();
41011 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41012 wxPyEndAllowThreads(__tstate);
41013 if (PyErr_Occurred()) SWIG_fail;
41014 }
41015 {
41016 resultobj = wxPyMake_wxObject(result, (bool)0);
41017 }
41018 return resultobj;
41019 fail:
41020 return NULL;
41021 }
41022
41023
41024 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41025 PyObject *resultobj = 0;
41026 wxMenu *arg1 = (wxMenu *) 0 ;
41027 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41028 void *argp1 = 0 ;
41029 int res1 = 0 ;
41030 void *argp2 = 0 ;
41031 int res2 = 0 ;
41032 PyObject * obj0 = 0 ;
41033 PyObject * obj1 = 0 ;
41034 char * kwnames[] = {
41035 (char *) "self",(char *) "menubar", NULL
41036 };
41037
41038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41040 if (!SWIG_IsOK(res1)) {
41041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41042 }
41043 arg1 = reinterpret_cast< wxMenu * >(argp1);
41044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41045 if (!SWIG_IsOK(res2)) {
41046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41047 }
41048 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41049 {
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 (arg1)->Attach(arg2);
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 resultobj = SWIG_Py_Void();
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41063 PyObject *resultobj = 0;
41064 wxMenu *arg1 = (wxMenu *) 0 ;
41065 void *argp1 = 0 ;
41066 int res1 = 0 ;
41067 PyObject *swig_obj[1] ;
41068
41069 if (!args) SWIG_fail;
41070 swig_obj[0] = args;
41071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41072 if (!SWIG_IsOK(res1)) {
41073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41074 }
41075 arg1 = reinterpret_cast< wxMenu * >(argp1);
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 (arg1)->Detach();
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 resultobj = SWIG_Py_Void();
41083 return resultobj;
41084 fail:
41085 return NULL;
41086 }
41087
41088
41089 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41090 PyObject *resultobj = 0;
41091 wxMenu *arg1 = (wxMenu *) 0 ;
41092 bool result;
41093 void *argp1 = 0 ;
41094 int res1 = 0 ;
41095 PyObject *swig_obj[1] ;
41096
41097 if (!args) SWIG_fail;
41098 swig_obj[0] = args;
41099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41100 if (!SWIG_IsOK(res1)) {
41101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41102 }
41103 arg1 = reinterpret_cast< wxMenu * >(argp1);
41104 {
41105 PyThreadState* __tstate = wxPyBeginAllowThreads();
41106 result = (bool)((wxMenu const *)arg1)->IsAttached();
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 {
41111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41112 }
41113 return resultobj;
41114 fail:
41115 return NULL;
41116 }
41117
41118
41119 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj = 0;
41121 wxMenu *arg1 = (wxMenu *) 0 ;
41122 wxMenu *arg2 = (wxMenu *) 0 ;
41123 void *argp1 = 0 ;
41124 int res1 = 0 ;
41125 void *argp2 = 0 ;
41126 int res2 = 0 ;
41127 PyObject * obj0 = 0 ;
41128 PyObject * obj1 = 0 ;
41129 char * kwnames[] = {
41130 (char *) "self",(char *) "parent", NULL
41131 };
41132
41133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41135 if (!SWIG_IsOK(res1)) {
41136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41137 }
41138 arg1 = reinterpret_cast< wxMenu * >(argp1);
41139 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41140 if (!SWIG_IsOK(res2)) {
41141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41142 }
41143 arg2 = reinterpret_cast< wxMenu * >(argp2);
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 (arg1)->SetParent(arg2);
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 resultobj = SWIG_Py_Void();
41151 return resultobj;
41152 fail:
41153 return NULL;
41154 }
41155
41156
41157 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41158 PyObject *resultobj = 0;
41159 wxMenu *arg1 = (wxMenu *) 0 ;
41160 wxMenu *result = 0 ;
41161 void *argp1 = 0 ;
41162 int res1 = 0 ;
41163 PyObject *swig_obj[1] ;
41164
41165 if (!args) SWIG_fail;
41166 swig_obj[0] = args;
41167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41168 if (!SWIG_IsOK(res1)) {
41169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41170 }
41171 arg1 = reinterpret_cast< wxMenu * >(argp1);
41172 {
41173 PyThreadState* __tstate = wxPyBeginAllowThreads();
41174 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41175 wxPyEndAllowThreads(__tstate);
41176 if (PyErr_Occurred()) SWIG_fail;
41177 }
41178 {
41179 resultobj = wxPyMake_wxObject(result, 0);
41180 }
41181 return resultobj;
41182 fail:
41183 return NULL;
41184 }
41185
41186
41187 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41188 PyObject *obj;
41189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41190 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41191 return SWIG_Py_Void();
41192 }
41193
41194 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41195 return SWIG_Python_InitShadowInstance(args);
41196 }
41197
41198 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41199 PyObject *resultobj = 0;
41200 long arg1 = (long) 0 ;
41201 wxMenuBar *result = 0 ;
41202 long val1 ;
41203 int ecode1 = 0 ;
41204 PyObject * obj0 = 0 ;
41205 char * kwnames[] = {
41206 (char *) "style", NULL
41207 };
41208
41209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41210 if (obj0) {
41211 ecode1 = SWIG_AsVal_long(obj0, &val1);
41212 if (!SWIG_IsOK(ecode1)) {
41213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41214 }
41215 arg1 = static_cast< long >(val1);
41216 }
41217 {
41218 if (!wxPyCheckForApp()) SWIG_fail;
41219 PyThreadState* __tstate = wxPyBeginAllowThreads();
41220 result = (wxMenuBar *)new wxMenuBar(arg1);
41221 wxPyEndAllowThreads(__tstate);
41222 if (PyErr_Occurred()) SWIG_fail;
41223 }
41224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41225 return resultobj;
41226 fail:
41227 return NULL;
41228 }
41229
41230
41231 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41232 PyObject *resultobj = 0;
41233 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41234 wxMenu *arg2 = (wxMenu *) 0 ;
41235 wxString *arg3 = 0 ;
41236 bool result;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 void *argp2 = 0 ;
41240 int res2 = 0 ;
41241 bool temp3 = false ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 PyObject * obj2 = 0 ;
41245 char * kwnames[] = {
41246 (char *) "self",(char *) "menu",(char *) "title", NULL
41247 };
41248
41249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41251 if (!SWIG_IsOK(res1)) {
41252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41253 }
41254 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41256 if (!SWIG_IsOK(res2)) {
41257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41258 }
41259 arg2 = reinterpret_cast< wxMenu * >(argp2);
41260 {
41261 arg3 = wxString_in_helper(obj2);
41262 if (arg3 == NULL) SWIG_fail;
41263 temp3 = true;
41264 }
41265 {
41266 PyThreadState* __tstate = wxPyBeginAllowThreads();
41267 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41268 wxPyEndAllowThreads(__tstate);
41269 if (PyErr_Occurred()) SWIG_fail;
41270 }
41271 {
41272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41273 }
41274 {
41275 if (temp3)
41276 delete arg3;
41277 }
41278 return resultobj;
41279 fail:
41280 {
41281 if (temp3)
41282 delete arg3;
41283 }
41284 return NULL;
41285 }
41286
41287
41288 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41289 PyObject *resultobj = 0;
41290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41291 size_t arg2 ;
41292 wxMenu *arg3 = (wxMenu *) 0 ;
41293 wxString *arg4 = 0 ;
41294 bool result;
41295 void *argp1 = 0 ;
41296 int res1 = 0 ;
41297 size_t val2 ;
41298 int ecode2 = 0 ;
41299 void *argp3 = 0 ;
41300 int res3 = 0 ;
41301 bool temp4 = false ;
41302 PyObject * obj0 = 0 ;
41303 PyObject * obj1 = 0 ;
41304 PyObject * obj2 = 0 ;
41305 PyObject * obj3 = 0 ;
41306 char * kwnames[] = {
41307 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41308 };
41309
41310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41312 if (!SWIG_IsOK(res1)) {
41313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41314 }
41315 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41316 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41317 if (!SWIG_IsOK(ecode2)) {
41318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41319 }
41320 arg2 = static_cast< size_t >(val2);
41321 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41322 if (!SWIG_IsOK(res3)) {
41323 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41324 }
41325 arg3 = reinterpret_cast< wxMenu * >(argp3);
41326 {
41327 arg4 = wxString_in_helper(obj3);
41328 if (arg4 == NULL) SWIG_fail;
41329 temp4 = true;
41330 }
41331 {
41332 PyThreadState* __tstate = wxPyBeginAllowThreads();
41333 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41334 wxPyEndAllowThreads(__tstate);
41335 if (PyErr_Occurred()) SWIG_fail;
41336 }
41337 {
41338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41339 }
41340 {
41341 if (temp4)
41342 delete arg4;
41343 }
41344 return resultobj;
41345 fail:
41346 {
41347 if (temp4)
41348 delete arg4;
41349 }
41350 return NULL;
41351 }
41352
41353
41354 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41355 PyObject *resultobj = 0;
41356 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41357 size_t result;
41358 void *argp1 = 0 ;
41359 int res1 = 0 ;
41360 PyObject *swig_obj[1] ;
41361
41362 if (!args) SWIG_fail;
41363 swig_obj[0] = args;
41364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41365 if (!SWIG_IsOK(res1)) {
41366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41367 }
41368 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41369 {
41370 PyThreadState* __tstate = wxPyBeginAllowThreads();
41371 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41372 wxPyEndAllowThreads(__tstate);
41373 if (PyErr_Occurred()) SWIG_fail;
41374 }
41375 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj = 0;
41384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41385 size_t arg2 ;
41386 wxMenu *result = 0 ;
41387 void *argp1 = 0 ;
41388 int res1 = 0 ;
41389 size_t val2 ;
41390 int ecode2 = 0 ;
41391 PyObject * obj0 = 0 ;
41392 PyObject * obj1 = 0 ;
41393 char * kwnames[] = {
41394 (char *) "self",(char *) "pos", NULL
41395 };
41396
41397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41399 if (!SWIG_IsOK(res1)) {
41400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41401 }
41402 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41403 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41404 if (!SWIG_IsOK(ecode2)) {
41405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41406 }
41407 arg2 = static_cast< size_t >(val2);
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41411 wxPyEndAllowThreads(__tstate);
41412 if (PyErr_Occurred()) SWIG_fail;
41413 }
41414 {
41415 resultobj = wxPyMake_wxObject(result, 0);
41416 }
41417 return resultobj;
41418 fail:
41419 return NULL;
41420 }
41421
41422
41423 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41424 PyObject *resultobj = 0;
41425 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41426 size_t arg2 ;
41427 wxMenu *arg3 = (wxMenu *) 0 ;
41428 wxString *arg4 = 0 ;
41429 wxMenu *result = 0 ;
41430 void *argp1 = 0 ;
41431 int res1 = 0 ;
41432 size_t val2 ;
41433 int ecode2 = 0 ;
41434 void *argp3 = 0 ;
41435 int res3 = 0 ;
41436 bool temp4 = false ;
41437 PyObject * obj0 = 0 ;
41438 PyObject * obj1 = 0 ;
41439 PyObject * obj2 = 0 ;
41440 PyObject * obj3 = 0 ;
41441 char * kwnames[] = {
41442 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41443 };
41444
41445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41447 if (!SWIG_IsOK(res1)) {
41448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41449 }
41450 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41451 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41452 if (!SWIG_IsOK(ecode2)) {
41453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41454 }
41455 arg2 = static_cast< size_t >(val2);
41456 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41457 if (!SWIG_IsOK(res3)) {
41458 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41459 }
41460 arg3 = reinterpret_cast< wxMenu * >(argp3);
41461 {
41462 arg4 = wxString_in_helper(obj3);
41463 if (arg4 == NULL) SWIG_fail;
41464 temp4 = true;
41465 }
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41469 wxPyEndAllowThreads(__tstate);
41470 if (PyErr_Occurred()) SWIG_fail;
41471 }
41472 {
41473 resultobj = wxPyMake_wxObject(result, 0);
41474 }
41475 {
41476 if (temp4)
41477 delete arg4;
41478 }
41479 return resultobj;
41480 fail:
41481 {
41482 if (temp4)
41483 delete arg4;
41484 }
41485 return NULL;
41486 }
41487
41488
41489 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj = 0;
41491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41492 size_t arg2 ;
41493 wxMenu *result = 0 ;
41494 void *argp1 = 0 ;
41495 int res1 = 0 ;
41496 size_t val2 ;
41497 int ecode2 = 0 ;
41498 PyObject * obj0 = 0 ;
41499 PyObject * obj1 = 0 ;
41500 char * kwnames[] = {
41501 (char *) "self",(char *) "pos", NULL
41502 };
41503
41504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41506 if (!SWIG_IsOK(res1)) {
41507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41508 }
41509 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41510 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41511 if (!SWIG_IsOK(ecode2)) {
41512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41513 }
41514 arg2 = static_cast< size_t >(val2);
41515 {
41516 PyThreadState* __tstate = wxPyBeginAllowThreads();
41517 result = (wxMenu *)(arg1)->Remove(arg2);
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 {
41522 resultobj = wxPyMake_wxObject(result, 0);
41523 }
41524 return resultobj;
41525 fail:
41526 return NULL;
41527 }
41528
41529
41530 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj = 0;
41532 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41533 size_t arg2 ;
41534 bool arg3 ;
41535 void *argp1 = 0 ;
41536 int res1 = 0 ;
41537 size_t val2 ;
41538 int ecode2 = 0 ;
41539 bool val3 ;
41540 int ecode3 = 0 ;
41541 PyObject * obj0 = 0 ;
41542 PyObject * obj1 = 0 ;
41543 PyObject * obj2 = 0 ;
41544 char * kwnames[] = {
41545 (char *) "self",(char *) "pos",(char *) "enable", NULL
41546 };
41547
41548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41550 if (!SWIG_IsOK(res1)) {
41551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41552 }
41553 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41554 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41555 if (!SWIG_IsOK(ecode2)) {
41556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41557 }
41558 arg2 = static_cast< size_t >(val2);
41559 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41560 if (!SWIG_IsOK(ecode3)) {
41561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41562 }
41563 arg3 = static_cast< bool >(val3);
41564 {
41565 PyThreadState* __tstate = wxPyBeginAllowThreads();
41566 (arg1)->EnableTop(arg2,arg3);
41567 wxPyEndAllowThreads(__tstate);
41568 if (PyErr_Occurred()) SWIG_fail;
41569 }
41570 resultobj = SWIG_Py_Void();
41571 return resultobj;
41572 fail:
41573 return NULL;
41574 }
41575
41576
41577 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41578 PyObject *resultobj = 0;
41579 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41580 size_t arg2 ;
41581 bool result;
41582 void *argp1 = 0 ;
41583 int res1 = 0 ;
41584 size_t val2 ;
41585 int ecode2 = 0 ;
41586 PyObject * obj0 = 0 ;
41587 PyObject * obj1 = 0 ;
41588 char * kwnames[] = {
41589 (char *) "self",(char *) "pos", NULL
41590 };
41591
41592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41594 if (!SWIG_IsOK(res1)) {
41595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41596 }
41597 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41598 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41599 if (!SWIG_IsOK(ecode2)) {
41600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41601 }
41602 arg2 = static_cast< size_t >(val2);
41603 {
41604 PyThreadState* __tstate = wxPyBeginAllowThreads();
41605 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41606 wxPyEndAllowThreads(__tstate);
41607 if (PyErr_Occurred()) SWIG_fail;
41608 }
41609 {
41610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41611 }
41612 return resultobj;
41613 fail:
41614 return NULL;
41615 }
41616
41617
41618 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41619 PyObject *resultobj = 0;
41620 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41621 size_t arg2 ;
41622 wxString *arg3 = 0 ;
41623 void *argp1 = 0 ;
41624 int res1 = 0 ;
41625 size_t val2 ;
41626 int ecode2 = 0 ;
41627 bool temp3 = false ;
41628 PyObject * obj0 = 0 ;
41629 PyObject * obj1 = 0 ;
41630 PyObject * obj2 = 0 ;
41631 char * kwnames[] = {
41632 (char *) "self",(char *) "pos",(char *) "label", NULL
41633 };
41634
41635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41639 }
41640 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41641 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41642 if (!SWIG_IsOK(ecode2)) {
41643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41644 }
41645 arg2 = static_cast< size_t >(val2);
41646 {
41647 arg3 = wxString_in_helper(obj2);
41648 if (arg3 == NULL) SWIG_fail;
41649 temp3 = true;
41650 }
41651 {
41652 PyThreadState* __tstate = wxPyBeginAllowThreads();
41653 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41654 wxPyEndAllowThreads(__tstate);
41655 if (PyErr_Occurred()) SWIG_fail;
41656 }
41657 resultobj = SWIG_Py_Void();
41658 {
41659 if (temp3)
41660 delete arg3;
41661 }
41662 return resultobj;
41663 fail:
41664 {
41665 if (temp3)
41666 delete arg3;
41667 }
41668 return NULL;
41669 }
41670
41671
41672 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj = 0;
41674 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41675 size_t arg2 ;
41676 wxString result;
41677 void *argp1 = 0 ;
41678 int res1 = 0 ;
41679 size_t val2 ;
41680 int ecode2 = 0 ;
41681 PyObject * obj0 = 0 ;
41682 PyObject * obj1 = 0 ;
41683 char * kwnames[] = {
41684 (char *) "self",(char *) "pos", NULL
41685 };
41686
41687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41689 if (!SWIG_IsOK(res1)) {
41690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41691 }
41692 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41694 if (!SWIG_IsOK(ecode2)) {
41695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41696 }
41697 arg2 = static_cast< size_t >(val2);
41698 {
41699 PyThreadState* __tstate = wxPyBeginAllowThreads();
41700 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41701 wxPyEndAllowThreads(__tstate);
41702 if (PyErr_Occurred()) SWIG_fail;
41703 }
41704 {
41705 #if wxUSE_UNICODE
41706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41707 #else
41708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41709 #endif
41710 }
41711 return resultobj;
41712 fail:
41713 return NULL;
41714 }
41715
41716
41717 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41718 PyObject *resultobj = 0;
41719 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41720 wxString *arg2 = 0 ;
41721 wxString *arg3 = 0 ;
41722 int result;
41723 void *argp1 = 0 ;
41724 int res1 = 0 ;
41725 bool temp2 = false ;
41726 bool temp3 = false ;
41727 PyObject * obj0 = 0 ;
41728 PyObject * obj1 = 0 ;
41729 PyObject * obj2 = 0 ;
41730 char * kwnames[] = {
41731 (char *) "self",(char *) "menu",(char *) "item", NULL
41732 };
41733
41734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41736 if (!SWIG_IsOK(res1)) {
41737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41738 }
41739 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41740 {
41741 arg2 = wxString_in_helper(obj1);
41742 if (arg2 == NULL) SWIG_fail;
41743 temp2 = true;
41744 }
41745 {
41746 arg3 = wxString_in_helper(obj2);
41747 if (arg3 == NULL) SWIG_fail;
41748 temp3 = true;
41749 }
41750 {
41751 PyThreadState* __tstate = wxPyBeginAllowThreads();
41752 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41753 wxPyEndAllowThreads(__tstate);
41754 if (PyErr_Occurred()) SWIG_fail;
41755 }
41756 resultobj = SWIG_From_int(static_cast< int >(result));
41757 {
41758 if (temp2)
41759 delete arg2;
41760 }
41761 {
41762 if (temp3)
41763 delete arg3;
41764 }
41765 return resultobj;
41766 fail:
41767 {
41768 if (temp2)
41769 delete arg2;
41770 }
41771 {
41772 if (temp3)
41773 delete arg3;
41774 }
41775 return NULL;
41776 }
41777
41778
41779 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41780 PyObject *resultobj = 0;
41781 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41782 int arg2 ;
41783 wxMenuItem *result = 0 ;
41784 void *argp1 = 0 ;
41785 int res1 = 0 ;
41786 int val2 ;
41787 int ecode2 = 0 ;
41788 PyObject * obj0 = 0 ;
41789 PyObject * obj1 = 0 ;
41790 char * kwnames[] = {
41791 (char *) "self",(char *) "id", NULL
41792 };
41793
41794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41796 if (!SWIG_IsOK(res1)) {
41797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41798 }
41799 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41800 ecode2 = SWIG_AsVal_int(obj1, &val2);
41801 if (!SWIG_IsOK(ecode2)) {
41802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41803 }
41804 arg2 = static_cast< int >(val2);
41805 {
41806 PyThreadState* __tstate = wxPyBeginAllowThreads();
41807 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41808 wxPyEndAllowThreads(__tstate);
41809 if (PyErr_Occurred()) SWIG_fail;
41810 }
41811 {
41812 resultobj = wxPyMake_wxObject(result, (bool)0);
41813 }
41814 return resultobj;
41815 fail:
41816 return NULL;
41817 }
41818
41819
41820 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41821 PyObject *resultobj = 0;
41822 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41823 wxString *arg2 = 0 ;
41824 int result;
41825 void *argp1 = 0 ;
41826 int res1 = 0 ;
41827 bool temp2 = false ;
41828 PyObject * obj0 = 0 ;
41829 PyObject * obj1 = 0 ;
41830 char * kwnames[] = {
41831 (char *) "self",(char *) "title", NULL
41832 };
41833
41834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) 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_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41838 }
41839 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41840 {
41841 arg2 = wxString_in_helper(obj1);
41842 if (arg2 == NULL) SWIG_fail;
41843 temp2 = true;
41844 }
41845 {
41846 PyThreadState* __tstate = wxPyBeginAllowThreads();
41847 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41848 wxPyEndAllowThreads(__tstate);
41849 if (PyErr_Occurred()) SWIG_fail;
41850 }
41851 resultobj = SWIG_From_int(static_cast< int >(result));
41852 {
41853 if (temp2)
41854 delete arg2;
41855 }
41856 return resultobj;
41857 fail:
41858 {
41859 if (temp2)
41860 delete arg2;
41861 }
41862 return NULL;
41863 }
41864
41865
41866 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41867 PyObject *resultobj = 0;
41868 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41869 int arg2 ;
41870 bool arg3 ;
41871 void *argp1 = 0 ;
41872 int res1 = 0 ;
41873 int val2 ;
41874 int ecode2 = 0 ;
41875 bool val3 ;
41876 int ecode3 = 0 ;
41877 PyObject * obj0 = 0 ;
41878 PyObject * obj1 = 0 ;
41879 PyObject * obj2 = 0 ;
41880 char * kwnames[] = {
41881 (char *) "self",(char *) "id",(char *) "enable", NULL
41882 };
41883
41884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41886 if (!SWIG_IsOK(res1)) {
41887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41888 }
41889 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41890 ecode2 = SWIG_AsVal_int(obj1, &val2);
41891 if (!SWIG_IsOK(ecode2)) {
41892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41893 }
41894 arg2 = static_cast< int >(val2);
41895 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41896 if (!SWIG_IsOK(ecode3)) {
41897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41898 }
41899 arg3 = static_cast< bool >(val3);
41900 {
41901 PyThreadState* __tstate = wxPyBeginAllowThreads();
41902 (arg1)->Enable(arg2,arg3);
41903 wxPyEndAllowThreads(__tstate);
41904 if (PyErr_Occurred()) SWIG_fail;
41905 }
41906 resultobj = SWIG_Py_Void();
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj = 0;
41915 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41916 int arg2 ;
41917 bool arg3 ;
41918 void *argp1 = 0 ;
41919 int res1 = 0 ;
41920 int val2 ;
41921 int ecode2 = 0 ;
41922 bool val3 ;
41923 int ecode3 = 0 ;
41924 PyObject * obj0 = 0 ;
41925 PyObject * obj1 = 0 ;
41926 PyObject * obj2 = 0 ;
41927 char * kwnames[] = {
41928 (char *) "self",(char *) "id",(char *) "check", NULL
41929 };
41930
41931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41933 if (!SWIG_IsOK(res1)) {
41934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41935 }
41936 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41937 ecode2 = SWIG_AsVal_int(obj1, &val2);
41938 if (!SWIG_IsOK(ecode2)) {
41939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41940 }
41941 arg2 = static_cast< int >(val2);
41942 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41943 if (!SWIG_IsOK(ecode3)) {
41944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41945 }
41946 arg3 = static_cast< bool >(val3);
41947 {
41948 PyThreadState* __tstate = wxPyBeginAllowThreads();
41949 (arg1)->Check(arg2,arg3);
41950 wxPyEndAllowThreads(__tstate);
41951 if (PyErr_Occurred()) SWIG_fail;
41952 }
41953 resultobj = SWIG_Py_Void();
41954 return resultobj;
41955 fail:
41956 return NULL;
41957 }
41958
41959
41960 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41961 PyObject *resultobj = 0;
41962 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41963 int arg2 ;
41964 bool result;
41965 void *argp1 = 0 ;
41966 int res1 = 0 ;
41967 int val2 ;
41968 int ecode2 = 0 ;
41969 PyObject * obj0 = 0 ;
41970 PyObject * obj1 = 0 ;
41971 char * kwnames[] = {
41972 (char *) "self",(char *) "id", NULL
41973 };
41974
41975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41977 if (!SWIG_IsOK(res1)) {
41978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41979 }
41980 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41981 ecode2 = SWIG_AsVal_int(obj1, &val2);
41982 if (!SWIG_IsOK(ecode2)) {
41983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41984 }
41985 arg2 = static_cast< int >(val2);
41986 {
41987 PyThreadState* __tstate = wxPyBeginAllowThreads();
41988 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41989 wxPyEndAllowThreads(__tstate);
41990 if (PyErr_Occurred()) SWIG_fail;
41991 }
41992 {
41993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41994 }
41995 return resultobj;
41996 fail:
41997 return NULL;
41998 }
41999
42000
42001 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42002 PyObject *resultobj = 0;
42003 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42004 int arg2 ;
42005 bool result;
42006 void *argp1 = 0 ;
42007 int res1 = 0 ;
42008 int val2 ;
42009 int ecode2 = 0 ;
42010 PyObject * obj0 = 0 ;
42011 PyObject * obj1 = 0 ;
42012 char * kwnames[] = {
42013 (char *) "self",(char *) "id", NULL
42014 };
42015
42016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42018 if (!SWIG_IsOK(res1)) {
42019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42020 }
42021 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42022 ecode2 = SWIG_AsVal_int(obj1, &val2);
42023 if (!SWIG_IsOK(ecode2)) {
42024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42025 }
42026 arg2 = static_cast< int >(val2);
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 {
42034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42035 }
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42043 PyObject *resultobj = 0;
42044 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42045 int arg2 ;
42046 wxString *arg3 = 0 ;
42047 void *argp1 = 0 ;
42048 int res1 = 0 ;
42049 int val2 ;
42050 int ecode2 = 0 ;
42051 bool temp3 = false ;
42052 PyObject * obj0 = 0 ;
42053 PyObject * obj1 = 0 ;
42054 PyObject * obj2 = 0 ;
42055 char * kwnames[] = {
42056 (char *) "self",(char *) "id",(char *) "label", NULL
42057 };
42058
42059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42061 if (!SWIG_IsOK(res1)) {
42062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42063 }
42064 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42065 ecode2 = SWIG_AsVal_int(obj1, &val2);
42066 if (!SWIG_IsOK(ecode2)) {
42067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42068 }
42069 arg2 = static_cast< int >(val2);
42070 {
42071 arg3 = wxString_in_helper(obj2);
42072 if (arg3 == NULL) SWIG_fail;
42073 temp3 = true;
42074 }
42075 {
42076 PyThreadState* __tstate = wxPyBeginAllowThreads();
42077 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42078 wxPyEndAllowThreads(__tstate);
42079 if (PyErr_Occurred()) SWIG_fail;
42080 }
42081 resultobj = SWIG_Py_Void();
42082 {
42083 if (temp3)
42084 delete arg3;
42085 }
42086 return resultobj;
42087 fail:
42088 {
42089 if (temp3)
42090 delete arg3;
42091 }
42092 return NULL;
42093 }
42094
42095
42096 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj = 0;
42098 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42099 int arg2 ;
42100 wxString result;
42101 void *argp1 = 0 ;
42102 int res1 = 0 ;
42103 int val2 ;
42104 int ecode2 = 0 ;
42105 PyObject * obj0 = 0 ;
42106 PyObject * obj1 = 0 ;
42107 char * kwnames[] = {
42108 (char *) "self",(char *) "id", NULL
42109 };
42110
42111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42113 if (!SWIG_IsOK(res1)) {
42114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42115 }
42116 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42117 ecode2 = SWIG_AsVal_int(obj1, &val2);
42118 if (!SWIG_IsOK(ecode2)) {
42119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42120 }
42121 arg2 = static_cast< int >(val2);
42122 {
42123 PyThreadState* __tstate = wxPyBeginAllowThreads();
42124 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42125 wxPyEndAllowThreads(__tstate);
42126 if (PyErr_Occurred()) SWIG_fail;
42127 }
42128 {
42129 #if wxUSE_UNICODE
42130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42131 #else
42132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42133 #endif
42134 }
42135 return resultobj;
42136 fail:
42137 return NULL;
42138 }
42139
42140
42141 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42142 PyObject *resultobj = 0;
42143 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42144 int arg2 ;
42145 wxString *arg3 = 0 ;
42146 void *argp1 = 0 ;
42147 int res1 = 0 ;
42148 int val2 ;
42149 int ecode2 = 0 ;
42150 bool temp3 = false ;
42151 PyObject * obj0 = 0 ;
42152 PyObject * obj1 = 0 ;
42153 PyObject * obj2 = 0 ;
42154 char * kwnames[] = {
42155 (char *) "self",(char *) "id",(char *) "helpString", NULL
42156 };
42157
42158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42160 if (!SWIG_IsOK(res1)) {
42161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42162 }
42163 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42164 ecode2 = SWIG_AsVal_int(obj1, &val2);
42165 if (!SWIG_IsOK(ecode2)) {
42166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42167 }
42168 arg2 = static_cast< int >(val2);
42169 {
42170 arg3 = wxString_in_helper(obj2);
42171 if (arg3 == NULL) SWIG_fail;
42172 temp3 = true;
42173 }
42174 {
42175 PyThreadState* __tstate = wxPyBeginAllowThreads();
42176 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42177 wxPyEndAllowThreads(__tstate);
42178 if (PyErr_Occurred()) SWIG_fail;
42179 }
42180 resultobj = SWIG_Py_Void();
42181 {
42182 if (temp3)
42183 delete arg3;
42184 }
42185 return resultobj;
42186 fail:
42187 {
42188 if (temp3)
42189 delete arg3;
42190 }
42191 return NULL;
42192 }
42193
42194
42195 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42196 PyObject *resultobj = 0;
42197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42198 int arg2 ;
42199 wxString result;
42200 void *argp1 = 0 ;
42201 int res1 = 0 ;
42202 int val2 ;
42203 int ecode2 = 0 ;
42204 PyObject * obj0 = 0 ;
42205 PyObject * obj1 = 0 ;
42206 char * kwnames[] = {
42207 (char *) "self",(char *) "id", NULL
42208 };
42209
42210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42212 if (!SWIG_IsOK(res1)) {
42213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42214 }
42215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42216 ecode2 = SWIG_AsVal_int(obj1, &val2);
42217 if (!SWIG_IsOK(ecode2)) {
42218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42219 }
42220 arg2 = static_cast< int >(val2);
42221 {
42222 PyThreadState* __tstate = wxPyBeginAllowThreads();
42223 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42224 wxPyEndAllowThreads(__tstate);
42225 if (PyErr_Occurred()) SWIG_fail;
42226 }
42227 {
42228 #if wxUSE_UNICODE
42229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42230 #else
42231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42232 #endif
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42241 PyObject *resultobj = 0;
42242 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42243 wxFrame *result = 0 ;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 PyObject *swig_obj[1] ;
42247
42248 if (!args) SWIG_fail;
42249 swig_obj[0] = args;
42250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42251 if (!SWIG_IsOK(res1)) {
42252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42253 }
42254 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 {
42262 resultobj = wxPyMake_wxObject(result, (bool)0);
42263 }
42264 return resultobj;
42265 fail:
42266 return NULL;
42267 }
42268
42269
42270 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42271 PyObject *resultobj = 0;
42272 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42273 bool result;
42274 void *argp1 = 0 ;
42275 int res1 = 0 ;
42276 PyObject *swig_obj[1] ;
42277
42278 if (!args) SWIG_fail;
42279 swig_obj[0] = args;
42280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42281 if (!SWIG_IsOK(res1)) {
42282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42283 }
42284 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42285 {
42286 PyThreadState* __tstate = wxPyBeginAllowThreads();
42287 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42288 wxPyEndAllowThreads(__tstate);
42289 if (PyErr_Occurred()) SWIG_fail;
42290 }
42291 {
42292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42293 }
42294 return resultobj;
42295 fail:
42296 return NULL;
42297 }
42298
42299
42300 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42301 PyObject *resultobj = 0;
42302 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42303 wxFrame *arg2 = (wxFrame *) 0 ;
42304 void *argp1 = 0 ;
42305 int res1 = 0 ;
42306 void *argp2 = 0 ;
42307 int res2 = 0 ;
42308 PyObject * obj0 = 0 ;
42309 PyObject * obj1 = 0 ;
42310 char * kwnames[] = {
42311 (char *) "self",(char *) "frame", NULL
42312 };
42313
42314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42316 if (!SWIG_IsOK(res1)) {
42317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42318 }
42319 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42321 if (!SWIG_IsOK(res2)) {
42322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42323 }
42324 arg2 = reinterpret_cast< wxFrame * >(argp2);
42325 {
42326 PyThreadState* __tstate = wxPyBeginAllowThreads();
42327 (arg1)->Attach(arg2);
42328 wxPyEndAllowThreads(__tstate);
42329 if (PyErr_Occurred()) SWIG_fail;
42330 }
42331 resultobj = SWIG_Py_Void();
42332 return resultobj;
42333 fail:
42334 return NULL;
42335 }
42336
42337
42338 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42339 PyObject *resultobj = 0;
42340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42341 void *argp1 = 0 ;
42342 int res1 = 0 ;
42343 PyObject *swig_obj[1] ;
42344
42345 if (!args) SWIG_fail;
42346 swig_obj[0] = args;
42347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42348 if (!SWIG_IsOK(res1)) {
42349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42350 }
42351 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42352 {
42353 PyThreadState* __tstate = wxPyBeginAllowThreads();
42354 (arg1)->Detach();
42355 wxPyEndAllowThreads(__tstate);
42356 if (PyErr_Occurred()) SWIG_fail;
42357 }
42358 resultobj = SWIG_Py_Void();
42359 return resultobj;
42360 fail:
42361 return NULL;
42362 }
42363
42364
42365 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42366 PyObject *resultobj = 0;
42367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42368 void *argp1 = 0 ;
42369 int res1 = 0 ;
42370 PyObject *swig_obj[1] ;
42371
42372 if (!args) SWIG_fail;
42373 swig_obj[0] = args;
42374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42375 if (!SWIG_IsOK(res1)) {
42376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42377 }
42378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42379 {
42380 PyThreadState* __tstate = wxPyBeginAllowThreads();
42381 (arg1)->UpdateMenus();
42382 wxPyEndAllowThreads(__tstate);
42383 if (PyErr_Occurred()) SWIG_fail;
42384 }
42385 resultobj = SWIG_Py_Void();
42386 return resultobj;
42387 fail:
42388 return NULL;
42389 }
42390
42391
42392 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42393 PyObject *resultobj = 0;
42394 bool arg1 ;
42395 bool val1 ;
42396 int ecode1 = 0 ;
42397 PyObject * obj0 = 0 ;
42398 char * kwnames[] = {
42399 (char *) "enable", NULL
42400 };
42401
42402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42403 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42404 if (!SWIG_IsOK(ecode1)) {
42405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42406 }
42407 arg1 = static_cast< bool >(val1);
42408 {
42409 PyThreadState* __tstate = wxPyBeginAllowThreads();
42410 wxMenuBar_SetAutoWindowMenu(arg1);
42411 wxPyEndAllowThreads(__tstate);
42412 if (PyErr_Occurred()) SWIG_fail;
42413 }
42414 resultobj = SWIG_Py_Void();
42415 return resultobj;
42416 fail:
42417 return NULL;
42418 }
42419
42420
42421 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42422 PyObject *resultobj = 0;
42423 bool result;
42424
42425 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 result = (bool)wxMenuBar_GetAutoWindowMenu();
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 {
42433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42434 }
42435 return resultobj;
42436 fail:
42437 return NULL;
42438 }
42439
42440
42441 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42442 PyObject *obj;
42443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42444 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42445 return SWIG_Py_Void();
42446 }
42447
42448 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42449 return SWIG_Python_InitShadowInstance(args);
42450 }
42451
42452 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj = 0;
42454 wxMenu *arg1 = (wxMenu *) NULL ;
42455 int arg2 = (int) wxID_ANY ;
42456 wxString const &arg3_defvalue = wxPyEmptyString ;
42457 wxString *arg3 = (wxString *) &arg3_defvalue ;
42458 wxString const &arg4_defvalue = wxPyEmptyString ;
42459 wxString *arg4 = (wxString *) &arg4_defvalue ;
42460 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42461 wxMenu *arg6 = (wxMenu *) NULL ;
42462 wxMenuItem *result = 0 ;
42463 void *argp1 = 0 ;
42464 int res1 = 0 ;
42465 int val2 ;
42466 int ecode2 = 0 ;
42467 bool temp3 = false ;
42468 bool temp4 = false ;
42469 int val5 ;
42470 int ecode5 = 0 ;
42471 void *argp6 = 0 ;
42472 int res6 = 0 ;
42473 PyObject * obj0 = 0 ;
42474 PyObject * obj1 = 0 ;
42475 PyObject * obj2 = 0 ;
42476 PyObject * obj3 = 0 ;
42477 PyObject * obj4 = 0 ;
42478 PyObject * obj5 = 0 ;
42479 char * kwnames[] = {
42480 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42481 };
42482
42483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42484 if (obj0) {
42485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42486 if (!SWIG_IsOK(res1)) {
42487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42488 }
42489 arg1 = reinterpret_cast< wxMenu * >(argp1);
42490 }
42491 if (obj1) {
42492 ecode2 = SWIG_AsVal_int(obj1, &val2);
42493 if (!SWIG_IsOK(ecode2)) {
42494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42495 }
42496 arg2 = static_cast< int >(val2);
42497 }
42498 if (obj2) {
42499 {
42500 arg3 = wxString_in_helper(obj2);
42501 if (arg3 == NULL) SWIG_fail;
42502 temp3 = true;
42503 }
42504 }
42505 if (obj3) {
42506 {
42507 arg4 = wxString_in_helper(obj3);
42508 if (arg4 == NULL) SWIG_fail;
42509 temp4 = true;
42510 }
42511 }
42512 if (obj4) {
42513 ecode5 = SWIG_AsVal_int(obj4, &val5);
42514 if (!SWIG_IsOK(ecode5)) {
42515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42516 }
42517 arg5 = static_cast< wxItemKind >(val5);
42518 }
42519 if (obj5) {
42520 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42521 if (!SWIG_IsOK(res6)) {
42522 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42523 }
42524 arg6 = reinterpret_cast< wxMenu * >(argp6);
42525 }
42526 {
42527 PyThreadState* __tstate = wxPyBeginAllowThreads();
42528 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42529 wxPyEndAllowThreads(__tstate);
42530 if (PyErr_Occurred()) SWIG_fail;
42531 }
42532 {
42533 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42534 }
42535 {
42536 if (temp3)
42537 delete arg3;
42538 }
42539 {
42540 if (temp4)
42541 delete arg4;
42542 }
42543 return resultobj;
42544 fail:
42545 {
42546 if (temp3)
42547 delete arg3;
42548 }
42549 {
42550 if (temp4)
42551 delete arg4;
42552 }
42553 return NULL;
42554 }
42555
42556
42557 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42558 PyObject *resultobj = 0;
42559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42560 void *argp1 = 0 ;
42561 int res1 = 0 ;
42562 PyObject *swig_obj[1] ;
42563
42564 if (!args) SWIG_fail;
42565 swig_obj[0] = args;
42566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42567 if (!SWIG_IsOK(res1)) {
42568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42569 }
42570 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42571 {
42572 PyThreadState* __tstate = wxPyBeginAllowThreads();
42573 delete arg1;
42574
42575 wxPyEndAllowThreads(__tstate);
42576 if (PyErr_Occurred()) SWIG_fail;
42577 }
42578 resultobj = SWIG_Py_Void();
42579 return resultobj;
42580 fail:
42581 return NULL;
42582 }
42583
42584
42585 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42586 PyObject *resultobj = 0;
42587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42588 wxMenu *result = 0 ;
42589 void *argp1 = 0 ;
42590 int res1 = 0 ;
42591 PyObject *swig_obj[1] ;
42592
42593 if (!args) SWIG_fail;
42594 swig_obj[0] = args;
42595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42596 if (!SWIG_IsOK(res1)) {
42597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42598 }
42599 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42600 {
42601 PyThreadState* __tstate = wxPyBeginAllowThreads();
42602 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42603 wxPyEndAllowThreads(__tstate);
42604 if (PyErr_Occurred()) SWIG_fail;
42605 }
42606 {
42607 resultobj = wxPyMake_wxObject(result, 0);
42608 }
42609 return resultobj;
42610 fail:
42611 return NULL;
42612 }
42613
42614
42615 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42616 PyObject *resultobj = 0;
42617 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42618 wxMenu *arg2 = (wxMenu *) 0 ;
42619 void *argp1 = 0 ;
42620 int res1 = 0 ;
42621 void *argp2 = 0 ;
42622 int res2 = 0 ;
42623 PyObject * obj0 = 0 ;
42624 PyObject * obj1 = 0 ;
42625 char * kwnames[] = {
42626 (char *) "self",(char *) "menu", NULL
42627 };
42628
42629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42631 if (!SWIG_IsOK(res1)) {
42632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42633 }
42634 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42636 if (!SWIG_IsOK(res2)) {
42637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42638 }
42639 arg2 = reinterpret_cast< wxMenu * >(argp2);
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 (arg1)->SetMenu(arg2);
42643 wxPyEndAllowThreads(__tstate);
42644 if (PyErr_Occurred()) SWIG_fail;
42645 }
42646 resultobj = SWIG_Py_Void();
42647 return resultobj;
42648 fail:
42649 return NULL;
42650 }
42651
42652
42653 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42654 PyObject *resultobj = 0;
42655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42656 int arg2 ;
42657 void *argp1 = 0 ;
42658 int res1 = 0 ;
42659 int val2 ;
42660 int ecode2 = 0 ;
42661 PyObject * obj0 = 0 ;
42662 PyObject * obj1 = 0 ;
42663 char * kwnames[] = {
42664 (char *) "self",(char *) "id", NULL
42665 };
42666
42667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42669 if (!SWIG_IsOK(res1)) {
42670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42671 }
42672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42673 ecode2 = SWIG_AsVal_int(obj1, &val2);
42674 if (!SWIG_IsOK(ecode2)) {
42675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42676 }
42677 arg2 = static_cast< int >(val2);
42678 {
42679 PyThreadState* __tstate = wxPyBeginAllowThreads();
42680 (arg1)->SetId(arg2);
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 resultobj = SWIG_Py_Void();
42685 return resultobj;
42686 fail:
42687 return NULL;
42688 }
42689
42690
42691 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42692 PyObject *resultobj = 0;
42693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42694 int result;
42695 void *argp1 = 0 ;
42696 int res1 = 0 ;
42697 PyObject *swig_obj[1] ;
42698
42699 if (!args) SWIG_fail;
42700 swig_obj[0] = args;
42701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42702 if (!SWIG_IsOK(res1)) {
42703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42704 }
42705 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42706 {
42707 PyThreadState* __tstate = wxPyBeginAllowThreads();
42708 result = (int)((wxMenuItem const *)arg1)->GetId();
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 resultobj = SWIG_From_int(static_cast< int >(result));
42713 return resultobj;
42714 fail:
42715 return NULL;
42716 }
42717
42718
42719 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42720 PyObject *resultobj = 0;
42721 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42722 bool result;
42723 void *argp1 = 0 ;
42724 int res1 = 0 ;
42725 PyObject *swig_obj[1] ;
42726
42727 if (!args) SWIG_fail;
42728 swig_obj[0] = args;
42729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42730 if (!SWIG_IsOK(res1)) {
42731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42732 }
42733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42734 {
42735 PyThreadState* __tstate = wxPyBeginAllowThreads();
42736 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42737 wxPyEndAllowThreads(__tstate);
42738 if (PyErr_Occurred()) SWIG_fail;
42739 }
42740 {
42741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42742 }
42743 return resultobj;
42744 fail:
42745 return NULL;
42746 }
42747
42748
42749 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42750 PyObject *resultobj = 0;
42751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42752 wxString *arg2 = 0 ;
42753 void *argp1 = 0 ;
42754 int res1 = 0 ;
42755 bool temp2 = false ;
42756 PyObject * obj0 = 0 ;
42757 PyObject * obj1 = 0 ;
42758 char * kwnames[] = {
42759 (char *) "self",(char *) "str", NULL
42760 };
42761
42762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42764 if (!SWIG_IsOK(res1)) {
42765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42766 }
42767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42768 {
42769 arg2 = wxString_in_helper(obj1);
42770 if (arg2 == NULL) SWIG_fail;
42771 temp2 = true;
42772 }
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 (arg1)->SetText((wxString const &)*arg2);
42776 wxPyEndAllowThreads(__tstate);
42777 if (PyErr_Occurred()) SWIG_fail;
42778 }
42779 resultobj = SWIG_Py_Void();
42780 {
42781 if (temp2)
42782 delete arg2;
42783 }
42784 return resultobj;
42785 fail:
42786 {
42787 if (temp2)
42788 delete arg2;
42789 }
42790 return NULL;
42791 }
42792
42793
42794 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42795 PyObject *resultobj = 0;
42796 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42797 wxString result;
42798 void *argp1 = 0 ;
42799 int res1 = 0 ;
42800 PyObject *swig_obj[1] ;
42801
42802 if (!args) SWIG_fail;
42803 swig_obj[0] = args;
42804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42805 if (!SWIG_IsOK(res1)) {
42806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42807 }
42808 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42809 {
42810 PyThreadState* __tstate = wxPyBeginAllowThreads();
42811 result = ((wxMenuItem const *)arg1)->GetLabel();
42812 wxPyEndAllowThreads(__tstate);
42813 if (PyErr_Occurred()) SWIG_fail;
42814 }
42815 {
42816 #if wxUSE_UNICODE
42817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42818 #else
42819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42820 #endif
42821 }
42822 return resultobj;
42823 fail:
42824 return NULL;
42825 }
42826
42827
42828 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42829 PyObject *resultobj = 0;
42830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42831 wxString *result = 0 ;
42832 void *argp1 = 0 ;
42833 int res1 = 0 ;
42834 PyObject *swig_obj[1] ;
42835
42836 if (!args) SWIG_fail;
42837 swig_obj[0] = args;
42838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42839 if (!SWIG_IsOK(res1)) {
42840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42841 }
42842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42843 {
42844 PyThreadState* __tstate = wxPyBeginAllowThreads();
42845 {
42846 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42847 result = (wxString *) &_result_ref;
42848 }
42849 wxPyEndAllowThreads(__tstate);
42850 if (PyErr_Occurred()) SWIG_fail;
42851 }
42852 {
42853 #if wxUSE_UNICODE
42854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42855 #else
42856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42857 #endif
42858 }
42859 return resultobj;
42860 fail:
42861 return NULL;
42862 }
42863
42864
42865 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42866 PyObject *resultobj = 0;
42867 wxString *arg1 = 0 ;
42868 wxString result;
42869 bool temp1 = false ;
42870 PyObject * obj0 = 0 ;
42871 char * kwnames[] = {
42872 (char *) "text", NULL
42873 };
42874
42875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42876 {
42877 arg1 = wxString_in_helper(obj0);
42878 if (arg1 == NULL) SWIG_fail;
42879 temp1 = true;
42880 }
42881 {
42882 PyThreadState* __tstate = wxPyBeginAllowThreads();
42883 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42884 wxPyEndAllowThreads(__tstate);
42885 if (PyErr_Occurred()) SWIG_fail;
42886 }
42887 {
42888 #if wxUSE_UNICODE
42889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42890 #else
42891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42892 #endif
42893 }
42894 {
42895 if (temp1)
42896 delete arg1;
42897 }
42898 return resultobj;
42899 fail:
42900 {
42901 if (temp1)
42902 delete arg1;
42903 }
42904 return NULL;
42905 }
42906
42907
42908 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42909 PyObject *resultobj = 0;
42910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42911 wxItemKind result;
42912 void *argp1 = 0 ;
42913 int res1 = 0 ;
42914 PyObject *swig_obj[1] ;
42915
42916 if (!args) SWIG_fail;
42917 swig_obj[0] = args;
42918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42919 if (!SWIG_IsOK(res1)) {
42920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42921 }
42922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42923 {
42924 PyThreadState* __tstate = wxPyBeginAllowThreads();
42925 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42926 wxPyEndAllowThreads(__tstate);
42927 if (PyErr_Occurred()) SWIG_fail;
42928 }
42929 resultobj = SWIG_From_int(static_cast< int >(result));
42930 return resultobj;
42931 fail:
42932 return NULL;
42933 }
42934
42935
42936 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42937 PyObject *resultobj = 0;
42938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42939 wxItemKind arg2 ;
42940 void *argp1 = 0 ;
42941 int res1 = 0 ;
42942 int val2 ;
42943 int ecode2 = 0 ;
42944 PyObject * obj0 = 0 ;
42945 PyObject * obj1 = 0 ;
42946 char * kwnames[] = {
42947 (char *) "self",(char *) "kind", NULL
42948 };
42949
42950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42952 if (!SWIG_IsOK(res1)) {
42953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42954 }
42955 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42956 ecode2 = SWIG_AsVal_int(obj1, &val2);
42957 if (!SWIG_IsOK(ecode2)) {
42958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42959 }
42960 arg2 = static_cast< wxItemKind >(val2);
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 (arg1)->SetKind(arg2);
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 resultobj = SWIG_Py_Void();
42968 return resultobj;
42969 fail:
42970 return NULL;
42971 }
42972
42973
42974 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj = 0;
42976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42977 bool arg2 ;
42978 void *argp1 = 0 ;
42979 int res1 = 0 ;
42980 bool val2 ;
42981 int ecode2 = 0 ;
42982 PyObject * obj0 = 0 ;
42983 PyObject * obj1 = 0 ;
42984 char * kwnames[] = {
42985 (char *) "self",(char *) "checkable", NULL
42986 };
42987
42988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42990 if (!SWIG_IsOK(res1)) {
42991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42992 }
42993 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42995 if (!SWIG_IsOK(ecode2)) {
42996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42997 }
42998 arg2 = static_cast< bool >(val2);
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 (arg1)->SetCheckable(arg2);
43002 wxPyEndAllowThreads(__tstate);
43003 if (PyErr_Occurred()) SWIG_fail;
43004 }
43005 resultobj = SWIG_Py_Void();
43006 return resultobj;
43007 fail:
43008 return NULL;
43009 }
43010
43011
43012 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43013 PyObject *resultobj = 0;
43014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43015 bool result;
43016 void *argp1 = 0 ;
43017 int res1 = 0 ;
43018 PyObject *swig_obj[1] ;
43019
43020 if (!args) SWIG_fail;
43021 swig_obj[0] = args;
43022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43023 if (!SWIG_IsOK(res1)) {
43024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43025 }
43026 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43027 {
43028 PyThreadState* __tstate = wxPyBeginAllowThreads();
43029 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43030 wxPyEndAllowThreads(__tstate);
43031 if (PyErr_Occurred()) SWIG_fail;
43032 }
43033 {
43034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43035 }
43036 return resultobj;
43037 fail:
43038 return NULL;
43039 }
43040
43041
43042 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43043 PyObject *resultobj = 0;
43044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43045 bool result;
43046 void *argp1 = 0 ;
43047 int res1 = 0 ;
43048 PyObject *swig_obj[1] ;
43049
43050 if (!args) SWIG_fail;
43051 swig_obj[0] = args;
43052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43053 if (!SWIG_IsOK(res1)) {
43054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43055 }
43056 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43057 {
43058 PyThreadState* __tstate = wxPyBeginAllowThreads();
43059 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43060 wxPyEndAllowThreads(__tstate);
43061 if (PyErr_Occurred()) SWIG_fail;
43062 }
43063 {
43064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43065 }
43066 return resultobj;
43067 fail:
43068 return NULL;
43069 }
43070
43071
43072 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43073 PyObject *resultobj = 0;
43074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43075 wxMenu *arg2 = (wxMenu *) 0 ;
43076 void *argp1 = 0 ;
43077 int res1 = 0 ;
43078 void *argp2 = 0 ;
43079 int res2 = 0 ;
43080 PyObject * obj0 = 0 ;
43081 PyObject * obj1 = 0 ;
43082 char * kwnames[] = {
43083 (char *) "self",(char *) "menu", NULL
43084 };
43085
43086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43088 if (!SWIG_IsOK(res1)) {
43089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43090 }
43091 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43093 if (!SWIG_IsOK(res2)) {
43094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43095 }
43096 arg2 = reinterpret_cast< wxMenu * >(argp2);
43097 {
43098 PyThreadState* __tstate = wxPyBeginAllowThreads();
43099 (arg1)->SetSubMenu(arg2);
43100 wxPyEndAllowThreads(__tstate);
43101 if (PyErr_Occurred()) SWIG_fail;
43102 }
43103 resultobj = SWIG_Py_Void();
43104 return resultobj;
43105 fail:
43106 return NULL;
43107 }
43108
43109
43110 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43111 PyObject *resultobj = 0;
43112 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43113 wxMenu *result = 0 ;
43114 void *argp1 = 0 ;
43115 int res1 = 0 ;
43116 PyObject *swig_obj[1] ;
43117
43118 if (!args) SWIG_fail;
43119 swig_obj[0] = args;
43120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43121 if (!SWIG_IsOK(res1)) {
43122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43123 }
43124 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43128 wxPyEndAllowThreads(__tstate);
43129 if (PyErr_Occurred()) SWIG_fail;
43130 }
43131 {
43132 resultobj = wxPyMake_wxObject(result, 0);
43133 }
43134 return resultobj;
43135 fail:
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43141 PyObject *resultobj = 0;
43142 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43143 bool arg2 = (bool) true ;
43144 void *argp1 = 0 ;
43145 int res1 = 0 ;
43146 bool val2 ;
43147 int ecode2 = 0 ;
43148 PyObject * obj0 = 0 ;
43149 PyObject * obj1 = 0 ;
43150 char * kwnames[] = {
43151 (char *) "self",(char *) "enable", NULL
43152 };
43153
43154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43156 if (!SWIG_IsOK(res1)) {
43157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43158 }
43159 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43160 if (obj1) {
43161 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43162 if (!SWIG_IsOK(ecode2)) {
43163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43164 }
43165 arg2 = static_cast< bool >(val2);
43166 }
43167 {
43168 PyThreadState* __tstate = wxPyBeginAllowThreads();
43169 (arg1)->Enable(arg2);
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 resultobj = SWIG_Py_Void();
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43181 PyObject *resultobj = 0;
43182 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43183 bool result;
43184 void *argp1 = 0 ;
43185 int res1 = 0 ;
43186 PyObject *swig_obj[1] ;
43187
43188 if (!args) SWIG_fail;
43189 swig_obj[0] = args;
43190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43191 if (!SWIG_IsOK(res1)) {
43192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43193 }
43194 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43195 {
43196 PyThreadState* __tstate = wxPyBeginAllowThreads();
43197 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43198 wxPyEndAllowThreads(__tstate);
43199 if (PyErr_Occurred()) SWIG_fail;
43200 }
43201 {
43202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43203 }
43204 return resultobj;
43205 fail:
43206 return NULL;
43207 }
43208
43209
43210 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43211 PyObject *resultobj = 0;
43212 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43213 bool arg2 = (bool) true ;
43214 void *argp1 = 0 ;
43215 int res1 = 0 ;
43216 bool val2 ;
43217 int ecode2 = 0 ;
43218 PyObject * obj0 = 0 ;
43219 PyObject * obj1 = 0 ;
43220 char * kwnames[] = {
43221 (char *) "self",(char *) "check", NULL
43222 };
43223
43224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43226 if (!SWIG_IsOK(res1)) {
43227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43228 }
43229 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43230 if (obj1) {
43231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43232 if (!SWIG_IsOK(ecode2)) {
43233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43234 }
43235 arg2 = static_cast< bool >(val2);
43236 }
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 (arg1)->Check(arg2);
43240 wxPyEndAllowThreads(__tstate);
43241 if (PyErr_Occurred()) SWIG_fail;
43242 }
43243 resultobj = SWIG_Py_Void();
43244 return resultobj;
43245 fail:
43246 return NULL;
43247 }
43248
43249
43250 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43251 PyObject *resultobj = 0;
43252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43253 bool result;
43254 void *argp1 = 0 ;
43255 int res1 = 0 ;
43256 PyObject *swig_obj[1] ;
43257
43258 if (!args) SWIG_fail;
43259 swig_obj[0] = args;
43260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43261 if (!SWIG_IsOK(res1)) {
43262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43263 }
43264 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43265 {
43266 PyThreadState* __tstate = wxPyBeginAllowThreads();
43267 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43268 wxPyEndAllowThreads(__tstate);
43269 if (PyErr_Occurred()) SWIG_fail;
43270 }
43271 {
43272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43273 }
43274 return resultobj;
43275 fail:
43276 return NULL;
43277 }
43278
43279
43280 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43281 PyObject *resultobj = 0;
43282 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43283 void *argp1 = 0 ;
43284 int res1 = 0 ;
43285 PyObject *swig_obj[1] ;
43286
43287 if (!args) SWIG_fail;
43288 swig_obj[0] = args;
43289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43290 if (!SWIG_IsOK(res1)) {
43291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43292 }
43293 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43294 {
43295 PyThreadState* __tstate = wxPyBeginAllowThreads();
43296 (arg1)->Toggle();
43297 wxPyEndAllowThreads(__tstate);
43298 if (PyErr_Occurred()) SWIG_fail;
43299 }
43300 resultobj = SWIG_Py_Void();
43301 return resultobj;
43302 fail:
43303 return NULL;
43304 }
43305
43306
43307 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43308 PyObject *resultobj = 0;
43309 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43310 wxString *arg2 = 0 ;
43311 void *argp1 = 0 ;
43312 int res1 = 0 ;
43313 bool temp2 = false ;
43314 PyObject * obj0 = 0 ;
43315 PyObject * obj1 = 0 ;
43316 char * kwnames[] = {
43317 (char *) "self",(char *) "str", NULL
43318 };
43319
43320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43322 if (!SWIG_IsOK(res1)) {
43323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43324 }
43325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43326 {
43327 arg2 = wxString_in_helper(obj1);
43328 if (arg2 == NULL) SWIG_fail;
43329 temp2 = true;
43330 }
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 (arg1)->SetHelp((wxString const &)*arg2);
43334 wxPyEndAllowThreads(__tstate);
43335 if (PyErr_Occurred()) SWIG_fail;
43336 }
43337 resultobj = SWIG_Py_Void();
43338 {
43339 if (temp2)
43340 delete arg2;
43341 }
43342 return resultobj;
43343 fail:
43344 {
43345 if (temp2)
43346 delete arg2;
43347 }
43348 return NULL;
43349 }
43350
43351
43352 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43353 PyObject *resultobj = 0;
43354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43355 wxString *result = 0 ;
43356 void *argp1 = 0 ;
43357 int res1 = 0 ;
43358 PyObject *swig_obj[1] ;
43359
43360 if (!args) SWIG_fail;
43361 swig_obj[0] = args;
43362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43363 if (!SWIG_IsOK(res1)) {
43364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43365 }
43366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 {
43370 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43371 result = (wxString *) &_result_ref;
43372 }
43373 wxPyEndAllowThreads(__tstate);
43374 if (PyErr_Occurred()) SWIG_fail;
43375 }
43376 {
43377 #if wxUSE_UNICODE
43378 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43379 #else
43380 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43381 #endif
43382 }
43383 return resultobj;
43384 fail:
43385 return NULL;
43386 }
43387
43388
43389 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43390 PyObject *resultobj = 0;
43391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43392 wxAcceleratorEntry *result = 0 ;
43393 void *argp1 = 0 ;
43394 int res1 = 0 ;
43395 PyObject *swig_obj[1] ;
43396
43397 if (!args) SWIG_fail;
43398 swig_obj[0] = args;
43399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43400 if (!SWIG_IsOK(res1)) {
43401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43402 }
43403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43404 {
43405 PyThreadState* __tstate = wxPyBeginAllowThreads();
43406 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43407 wxPyEndAllowThreads(__tstate);
43408 if (PyErr_Occurred()) SWIG_fail;
43409 }
43410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43411 return resultobj;
43412 fail:
43413 return NULL;
43414 }
43415
43416
43417 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43418 PyObject *resultobj = 0;
43419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43420 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43421 void *argp1 = 0 ;
43422 int res1 = 0 ;
43423 void *argp2 = 0 ;
43424 int res2 = 0 ;
43425 PyObject * obj0 = 0 ;
43426 PyObject * obj1 = 0 ;
43427 char * kwnames[] = {
43428 (char *) "self",(char *) "accel", NULL
43429 };
43430
43431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43433 if (!SWIG_IsOK(res1)) {
43434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43435 }
43436 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43438 if (!SWIG_IsOK(res2)) {
43439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43440 }
43441 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43442 {
43443 PyThreadState* __tstate = wxPyBeginAllowThreads();
43444 (arg1)->SetAccel(arg2);
43445 wxPyEndAllowThreads(__tstate);
43446 if (PyErr_Occurred()) SWIG_fail;
43447 }
43448 resultobj = SWIG_Py_Void();
43449 return resultobj;
43450 fail:
43451 return NULL;
43452 }
43453
43454
43455 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43456 PyObject *resultobj = 0;
43457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43458 wxBitmap *arg2 = 0 ;
43459 void *argp1 = 0 ;
43460 int res1 = 0 ;
43461 void *argp2 = 0 ;
43462 int res2 = 0 ;
43463 PyObject * obj0 = 0 ;
43464 PyObject * obj1 = 0 ;
43465 char * kwnames[] = {
43466 (char *) "self",(char *) "bitmap", NULL
43467 };
43468
43469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43471 if (!SWIG_IsOK(res1)) {
43472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43473 }
43474 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43475 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43476 if (!SWIG_IsOK(res2)) {
43477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43478 }
43479 if (!argp2) {
43480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43481 }
43482 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43483 {
43484 PyThreadState* __tstate = wxPyBeginAllowThreads();
43485 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43486 wxPyEndAllowThreads(__tstate);
43487 if (PyErr_Occurred()) SWIG_fail;
43488 }
43489 resultobj = SWIG_Py_Void();
43490 return resultobj;
43491 fail:
43492 return NULL;
43493 }
43494
43495
43496 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43497 PyObject *resultobj = 0;
43498 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43499 wxBitmap *result = 0 ;
43500 void *argp1 = 0 ;
43501 int res1 = 0 ;
43502 PyObject *swig_obj[1] ;
43503
43504 if (!args) SWIG_fail;
43505 swig_obj[0] = args;
43506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43507 if (!SWIG_IsOK(res1)) {
43508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43509 }
43510 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43511 {
43512 PyThreadState* __tstate = wxPyBeginAllowThreads();
43513 {
43514 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43515 result = (wxBitmap *) &_result_ref;
43516 }
43517 wxPyEndAllowThreads(__tstate);
43518 if (PyErr_Occurred()) SWIG_fail;
43519 }
43520 {
43521 wxBitmap* resultptr = new wxBitmap(*result);
43522 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43523 }
43524 return resultobj;
43525 fail:
43526 return NULL;
43527 }
43528
43529
43530 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43531 PyObject *resultobj = 0;
43532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43533 wxFont *arg2 = 0 ;
43534 void *argp1 = 0 ;
43535 int res1 = 0 ;
43536 void *argp2 = 0 ;
43537 int res2 = 0 ;
43538 PyObject * obj0 = 0 ;
43539 PyObject * obj1 = 0 ;
43540 char * kwnames[] = {
43541 (char *) "self",(char *) "font", NULL
43542 };
43543
43544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43546 if (!SWIG_IsOK(res1)) {
43547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43548 }
43549 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43550 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43551 if (!SWIG_IsOK(res2)) {
43552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43553 }
43554 if (!argp2) {
43555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43556 }
43557 arg2 = reinterpret_cast< wxFont * >(argp2);
43558 {
43559 PyThreadState* __tstate = wxPyBeginAllowThreads();
43560 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 resultobj = SWIG_Py_Void();
43565 return resultobj;
43566 fail:
43567 return NULL;
43568 }
43569
43570
43571 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43572 PyObject *resultobj = 0;
43573 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43574 wxFont result;
43575 void *argp1 = 0 ;
43576 int res1 = 0 ;
43577 PyObject *swig_obj[1] ;
43578
43579 if (!args) SWIG_fail;
43580 swig_obj[0] = args;
43581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43582 if (!SWIG_IsOK(res1)) {
43583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43584 }
43585 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43586 {
43587 PyThreadState* __tstate = wxPyBeginAllowThreads();
43588 result = wxMenuItem_GetFont(arg1);
43589 wxPyEndAllowThreads(__tstate);
43590 if (PyErr_Occurred()) SWIG_fail;
43591 }
43592 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43593 return resultobj;
43594 fail:
43595 return NULL;
43596 }
43597
43598
43599 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43600 PyObject *resultobj = 0;
43601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43602 wxColour *arg2 = 0 ;
43603 void *argp1 = 0 ;
43604 int res1 = 0 ;
43605 wxColour temp2 ;
43606 PyObject * obj0 = 0 ;
43607 PyObject * obj1 = 0 ;
43608 char * kwnames[] = {
43609 (char *) "self",(char *) "colText", NULL
43610 };
43611
43612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43614 if (!SWIG_IsOK(res1)) {
43615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43616 }
43617 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43618 {
43619 arg2 = &temp2;
43620 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43621 }
43622 {
43623 PyThreadState* __tstate = wxPyBeginAllowThreads();
43624 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 resultobj = SWIG_Py_Void();
43629 return resultobj;
43630 fail:
43631 return NULL;
43632 }
43633
43634
43635 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43636 PyObject *resultobj = 0;
43637 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43638 wxColour result;
43639 void *argp1 = 0 ;
43640 int res1 = 0 ;
43641 PyObject *swig_obj[1] ;
43642
43643 if (!args) SWIG_fail;
43644 swig_obj[0] = args;
43645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43646 if (!SWIG_IsOK(res1)) {
43647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43648 }
43649 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43650 {
43651 PyThreadState* __tstate = wxPyBeginAllowThreads();
43652 result = wxMenuItem_GetTextColour(arg1);
43653 wxPyEndAllowThreads(__tstate);
43654 if (PyErr_Occurred()) SWIG_fail;
43655 }
43656 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43657 return resultobj;
43658 fail:
43659 return NULL;
43660 }
43661
43662
43663 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43664 PyObject *resultobj = 0;
43665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43666 wxColour *arg2 = 0 ;
43667 void *argp1 = 0 ;
43668 int res1 = 0 ;
43669 wxColour temp2 ;
43670 PyObject * obj0 = 0 ;
43671 PyObject * obj1 = 0 ;
43672 char * kwnames[] = {
43673 (char *) "self",(char *) "colBack", NULL
43674 };
43675
43676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43678 if (!SWIG_IsOK(res1)) {
43679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43680 }
43681 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43682 {
43683 arg2 = &temp2;
43684 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43685 }
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 resultobj = SWIG_Py_Void();
43693 return resultobj;
43694 fail:
43695 return NULL;
43696 }
43697
43698
43699 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43700 PyObject *resultobj = 0;
43701 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43702 wxColour result;
43703 void *argp1 = 0 ;
43704 int res1 = 0 ;
43705 PyObject *swig_obj[1] ;
43706
43707 if (!args) SWIG_fail;
43708 swig_obj[0] = args;
43709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43710 if (!SWIG_IsOK(res1)) {
43711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43712 }
43713 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43714 {
43715 PyThreadState* __tstate = wxPyBeginAllowThreads();
43716 result = wxMenuItem_GetBackgroundColour(arg1);
43717 wxPyEndAllowThreads(__tstate);
43718 if (PyErr_Occurred()) SWIG_fail;
43719 }
43720 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43721 return resultobj;
43722 fail:
43723 return NULL;
43724 }
43725
43726
43727 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43728 PyObject *resultobj = 0;
43729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43730 wxBitmap *arg2 = 0 ;
43731 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43732 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43733 void *argp1 = 0 ;
43734 int res1 = 0 ;
43735 void *argp2 = 0 ;
43736 int res2 = 0 ;
43737 void *argp3 = 0 ;
43738 int res3 = 0 ;
43739 PyObject * obj0 = 0 ;
43740 PyObject * obj1 = 0 ;
43741 PyObject * obj2 = 0 ;
43742 char * kwnames[] = {
43743 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43744 };
43745
43746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43748 if (!SWIG_IsOK(res1)) {
43749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43750 }
43751 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43753 if (!SWIG_IsOK(res2)) {
43754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43755 }
43756 if (!argp2) {
43757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43758 }
43759 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43760 if (obj2) {
43761 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43762 if (!SWIG_IsOK(res3)) {
43763 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43764 }
43765 if (!argp3) {
43766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43767 }
43768 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43769 }
43770 {
43771 PyThreadState* __tstate = wxPyBeginAllowThreads();
43772 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 resultobj = SWIG_Py_Void();
43777 return resultobj;
43778 fail:
43779 return NULL;
43780 }
43781
43782
43783 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43784 PyObject *resultobj = 0;
43785 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43786 wxBitmap *arg2 = 0 ;
43787 void *argp1 = 0 ;
43788 int res1 = 0 ;
43789 void *argp2 = 0 ;
43790 int res2 = 0 ;
43791 PyObject * obj0 = 0 ;
43792 PyObject * obj1 = 0 ;
43793 char * kwnames[] = {
43794 (char *) "self",(char *) "bmpDisabled", NULL
43795 };
43796
43797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43799 if (!SWIG_IsOK(res1)) {
43800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43801 }
43802 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43803 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43804 if (!SWIG_IsOK(res2)) {
43805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43806 }
43807 if (!argp2) {
43808 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43809 }
43810 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43811 {
43812 PyThreadState* __tstate = wxPyBeginAllowThreads();
43813 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43814 wxPyEndAllowThreads(__tstate);
43815 if (PyErr_Occurred()) SWIG_fail;
43816 }
43817 resultobj = SWIG_Py_Void();
43818 return resultobj;
43819 fail:
43820 return NULL;
43821 }
43822
43823
43824 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43825 PyObject *resultobj = 0;
43826 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43827 wxBitmap *result = 0 ;
43828 void *argp1 = 0 ;
43829 int res1 = 0 ;
43830 PyObject *swig_obj[1] ;
43831
43832 if (!args) SWIG_fail;
43833 swig_obj[0] = args;
43834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43835 if (!SWIG_IsOK(res1)) {
43836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43837 }
43838 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43839 {
43840 PyThreadState* __tstate = wxPyBeginAllowThreads();
43841 {
43842 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43843 result = (wxBitmap *) &_result_ref;
43844 }
43845 wxPyEndAllowThreads(__tstate);
43846 if (PyErr_Occurred()) SWIG_fail;
43847 }
43848 {
43849 wxBitmap* resultptr = new wxBitmap(*result);
43850 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43851 }
43852 return resultobj;
43853 fail:
43854 return NULL;
43855 }
43856
43857
43858 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43859 PyObject *resultobj = 0;
43860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43861 int arg2 ;
43862 void *argp1 = 0 ;
43863 int res1 = 0 ;
43864 int val2 ;
43865 int ecode2 = 0 ;
43866 PyObject * obj0 = 0 ;
43867 PyObject * obj1 = 0 ;
43868 char * kwnames[] = {
43869 (char *) "self",(char *) "nWidth", NULL
43870 };
43871
43872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43874 if (!SWIG_IsOK(res1)) {
43875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43876 }
43877 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43878 ecode2 = SWIG_AsVal_int(obj1, &val2);
43879 if (!SWIG_IsOK(ecode2)) {
43880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43881 }
43882 arg2 = static_cast< int >(val2);
43883 {
43884 PyThreadState* __tstate = wxPyBeginAllowThreads();
43885 wxMenuItem_SetMarginWidth(arg1,arg2);
43886 wxPyEndAllowThreads(__tstate);
43887 if (PyErr_Occurred()) SWIG_fail;
43888 }
43889 resultobj = SWIG_Py_Void();
43890 return resultobj;
43891 fail:
43892 return NULL;
43893 }
43894
43895
43896 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43897 PyObject *resultobj = 0;
43898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43899 int result;
43900 void *argp1 = 0 ;
43901 int res1 = 0 ;
43902 PyObject *swig_obj[1] ;
43903
43904 if (!args) SWIG_fail;
43905 swig_obj[0] = args;
43906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43907 if (!SWIG_IsOK(res1)) {
43908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43909 }
43910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43911 {
43912 PyThreadState* __tstate = wxPyBeginAllowThreads();
43913 result = (int)wxMenuItem_GetMarginWidth(arg1);
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 resultobj = SWIG_From_int(static_cast< int >(result));
43918 return resultobj;
43919 fail:
43920 return NULL;
43921 }
43922
43923
43924 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43925 PyObject *resultobj = 0;
43926 int result;
43927
43928 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 result = (int)wxMenuItem_GetDefaultMarginWidth();
43932 wxPyEndAllowThreads(__tstate);
43933 if (PyErr_Occurred()) SWIG_fail;
43934 }
43935 resultobj = SWIG_From_int(static_cast< int >(result));
43936 return resultobj;
43937 fail:
43938 return NULL;
43939 }
43940
43941
43942 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43943 PyObject *resultobj = 0;
43944 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43945 bool result;
43946 void *argp1 = 0 ;
43947 int res1 = 0 ;
43948 PyObject *swig_obj[1] ;
43949
43950 if (!args) SWIG_fail;
43951 swig_obj[0] = args;
43952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43953 if (!SWIG_IsOK(res1)) {
43954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43955 }
43956 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43957 {
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 {
43964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43965 }
43966 return resultobj;
43967 fail:
43968 return NULL;
43969 }
43970
43971
43972 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43973 PyObject *resultobj = 0;
43974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43975 bool arg2 = (bool) true ;
43976 void *argp1 = 0 ;
43977 int res1 = 0 ;
43978 bool val2 ;
43979 int ecode2 = 0 ;
43980 PyObject * obj0 = 0 ;
43981 PyObject * obj1 = 0 ;
43982 char * kwnames[] = {
43983 (char *) "self",(char *) "ownerDrawn", NULL
43984 };
43985
43986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43988 if (!SWIG_IsOK(res1)) {
43989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43990 }
43991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43992 if (obj1) {
43993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43994 if (!SWIG_IsOK(ecode2)) {
43995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43996 }
43997 arg2 = static_cast< bool >(val2);
43998 }
43999 {
44000 PyThreadState* __tstate = wxPyBeginAllowThreads();
44001 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44002 wxPyEndAllowThreads(__tstate);
44003 if (PyErr_Occurred()) SWIG_fail;
44004 }
44005 resultobj = SWIG_Py_Void();
44006 return resultobj;
44007 fail:
44008 return NULL;
44009 }
44010
44011
44012 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44013 PyObject *resultobj = 0;
44014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44015 void *argp1 = 0 ;
44016 int res1 = 0 ;
44017 PyObject *swig_obj[1] ;
44018
44019 if (!args) SWIG_fail;
44020 swig_obj[0] = args;
44021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44022 if (!SWIG_IsOK(res1)) {
44023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44024 }
44025 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44026 {
44027 PyThreadState* __tstate = wxPyBeginAllowThreads();
44028 wxMenuItem_ResetOwnerDrawn(arg1);
44029 wxPyEndAllowThreads(__tstate);
44030 if (PyErr_Occurred()) SWIG_fail;
44031 }
44032 resultobj = SWIG_Py_Void();
44033 return resultobj;
44034 fail:
44035 return NULL;
44036 }
44037
44038
44039 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44040 PyObject *obj;
44041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44042 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44043 return SWIG_Py_Void();
44044 }
44045
44046 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44047 return SWIG_Python_InitShadowInstance(args);
44048 }
44049
44050 SWIGINTERN int ControlNameStr_set(PyObject *) {
44051 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44052 return 1;
44053 }
44054
44055
44056 SWIGINTERN PyObject *ControlNameStr_get(void) {
44057 PyObject *pyobj = 0;
44058
44059 {
44060 #if wxUSE_UNICODE
44061 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44062 #else
44063 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44064 #endif
44065 }
44066 return pyobj;
44067 }
44068
44069
44070 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44071 PyObject *resultobj = 0;
44072 wxWindow *arg1 = (wxWindow *) 0 ;
44073 int arg2 = (int) -1 ;
44074 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44075 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44076 wxSize const &arg4_defvalue = wxDefaultSize ;
44077 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44078 long arg5 = (long) 0 ;
44079 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44080 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44081 wxString const &arg7_defvalue = wxPyControlNameStr ;
44082 wxString *arg7 = (wxString *) &arg7_defvalue ;
44083 wxControl *result = 0 ;
44084 void *argp1 = 0 ;
44085 int res1 = 0 ;
44086 int val2 ;
44087 int ecode2 = 0 ;
44088 wxPoint temp3 ;
44089 wxSize temp4 ;
44090 long val5 ;
44091 int ecode5 = 0 ;
44092 void *argp6 = 0 ;
44093 int res6 = 0 ;
44094 bool temp7 = false ;
44095 PyObject * obj0 = 0 ;
44096 PyObject * obj1 = 0 ;
44097 PyObject * obj2 = 0 ;
44098 PyObject * obj3 = 0 ;
44099 PyObject * obj4 = 0 ;
44100 PyObject * obj5 = 0 ;
44101 PyObject * obj6 = 0 ;
44102 char * kwnames[] = {
44103 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44104 };
44105
44106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44108 if (!SWIG_IsOK(res1)) {
44109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44110 }
44111 arg1 = reinterpret_cast< wxWindow * >(argp1);
44112 if (obj1) {
44113 ecode2 = SWIG_AsVal_int(obj1, &val2);
44114 if (!SWIG_IsOK(ecode2)) {
44115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44116 }
44117 arg2 = static_cast< int >(val2);
44118 }
44119 if (obj2) {
44120 {
44121 arg3 = &temp3;
44122 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44123 }
44124 }
44125 if (obj3) {
44126 {
44127 arg4 = &temp4;
44128 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44129 }
44130 }
44131 if (obj4) {
44132 ecode5 = SWIG_AsVal_long(obj4, &val5);
44133 if (!SWIG_IsOK(ecode5)) {
44134 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44135 }
44136 arg5 = static_cast< long >(val5);
44137 }
44138 if (obj5) {
44139 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44140 if (!SWIG_IsOK(res6)) {
44141 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44142 }
44143 if (!argp6) {
44144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44145 }
44146 arg6 = reinterpret_cast< wxValidator * >(argp6);
44147 }
44148 if (obj6) {
44149 {
44150 arg7 = wxString_in_helper(obj6);
44151 if (arg7 == NULL) SWIG_fail;
44152 temp7 = true;
44153 }
44154 }
44155 {
44156 if (!wxPyCheckForApp()) SWIG_fail;
44157 PyThreadState* __tstate = wxPyBeginAllowThreads();
44158 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44159 wxPyEndAllowThreads(__tstate);
44160 if (PyErr_Occurred()) SWIG_fail;
44161 }
44162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44163 {
44164 if (temp7)
44165 delete arg7;
44166 }
44167 return resultobj;
44168 fail:
44169 {
44170 if (temp7)
44171 delete arg7;
44172 }
44173 return NULL;
44174 }
44175
44176
44177 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44178 PyObject *resultobj = 0;
44179 wxControl *result = 0 ;
44180
44181 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44182 {
44183 if (!wxPyCheckForApp()) SWIG_fail;
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 result = (wxControl *)new wxControl();
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj = 0;
44198 wxControl *arg1 = (wxControl *) 0 ;
44199 wxWindow *arg2 = (wxWindow *) 0 ;
44200 int arg3 = (int) -1 ;
44201 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44202 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44203 wxSize const &arg5_defvalue = wxDefaultSize ;
44204 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44205 long arg6 = (long) 0 ;
44206 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44207 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44208 wxString const &arg8_defvalue = wxPyControlNameStr ;
44209 wxString *arg8 = (wxString *) &arg8_defvalue ;
44210 bool result;
44211 void *argp1 = 0 ;
44212 int res1 = 0 ;
44213 void *argp2 = 0 ;
44214 int res2 = 0 ;
44215 int val3 ;
44216 int ecode3 = 0 ;
44217 wxPoint temp4 ;
44218 wxSize temp5 ;
44219 long val6 ;
44220 int ecode6 = 0 ;
44221 void *argp7 = 0 ;
44222 int res7 = 0 ;
44223 bool temp8 = false ;
44224 PyObject * obj0 = 0 ;
44225 PyObject * obj1 = 0 ;
44226 PyObject * obj2 = 0 ;
44227 PyObject * obj3 = 0 ;
44228 PyObject * obj4 = 0 ;
44229 PyObject * obj5 = 0 ;
44230 PyObject * obj6 = 0 ;
44231 PyObject * obj7 = 0 ;
44232 char * kwnames[] = {
44233 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44234 };
44235
44236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44238 if (!SWIG_IsOK(res1)) {
44239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44240 }
44241 arg1 = reinterpret_cast< wxControl * >(argp1);
44242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44243 if (!SWIG_IsOK(res2)) {
44244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44245 }
44246 arg2 = reinterpret_cast< wxWindow * >(argp2);
44247 if (obj2) {
44248 ecode3 = SWIG_AsVal_int(obj2, &val3);
44249 if (!SWIG_IsOK(ecode3)) {
44250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44251 }
44252 arg3 = static_cast< int >(val3);
44253 }
44254 if (obj3) {
44255 {
44256 arg4 = &temp4;
44257 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44258 }
44259 }
44260 if (obj4) {
44261 {
44262 arg5 = &temp5;
44263 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44264 }
44265 }
44266 if (obj5) {
44267 ecode6 = SWIG_AsVal_long(obj5, &val6);
44268 if (!SWIG_IsOK(ecode6)) {
44269 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44270 }
44271 arg6 = static_cast< long >(val6);
44272 }
44273 if (obj6) {
44274 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44275 if (!SWIG_IsOK(res7)) {
44276 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44277 }
44278 if (!argp7) {
44279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44280 }
44281 arg7 = reinterpret_cast< wxValidator * >(argp7);
44282 }
44283 if (obj7) {
44284 {
44285 arg8 = wxString_in_helper(obj7);
44286 if (arg8 == NULL) SWIG_fail;
44287 temp8 = true;
44288 }
44289 }
44290 {
44291 PyThreadState* __tstate = wxPyBeginAllowThreads();
44292 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44293 wxPyEndAllowThreads(__tstate);
44294 if (PyErr_Occurred()) SWIG_fail;
44295 }
44296 {
44297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44298 }
44299 {
44300 if (temp8)
44301 delete arg8;
44302 }
44303 return resultobj;
44304 fail:
44305 {
44306 if (temp8)
44307 delete arg8;
44308 }
44309 return NULL;
44310 }
44311
44312
44313 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44314 PyObject *resultobj = 0;
44315 wxControl *arg1 = (wxControl *) 0 ;
44316 int result;
44317 void *argp1 = 0 ;
44318 int res1 = 0 ;
44319 PyObject *swig_obj[1] ;
44320
44321 if (!args) SWIG_fail;
44322 swig_obj[0] = args;
44323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44324 if (!SWIG_IsOK(res1)) {
44325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44326 }
44327 arg1 = reinterpret_cast< wxControl * >(argp1);
44328 {
44329 PyThreadState* __tstate = wxPyBeginAllowThreads();
44330 result = (int)((wxControl const *)arg1)->GetAlignment();
44331 wxPyEndAllowThreads(__tstate);
44332 if (PyErr_Occurred()) SWIG_fail;
44333 }
44334 resultobj = SWIG_From_int(static_cast< int >(result));
44335 return resultobj;
44336 fail:
44337 return NULL;
44338 }
44339
44340
44341 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44342 PyObject *resultobj = 0;
44343 wxControl *arg1 = (wxControl *) 0 ;
44344 wxString result;
44345 void *argp1 = 0 ;
44346 int res1 = 0 ;
44347 PyObject *swig_obj[1] ;
44348
44349 if (!args) SWIG_fail;
44350 swig_obj[0] = args;
44351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44352 if (!SWIG_IsOK(res1)) {
44353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44354 }
44355 arg1 = reinterpret_cast< wxControl * >(argp1);
44356 {
44357 PyThreadState* __tstate = wxPyBeginAllowThreads();
44358 result = ((wxControl const *)arg1)->GetLabelText();
44359 wxPyEndAllowThreads(__tstate);
44360 if (PyErr_Occurred()) SWIG_fail;
44361 }
44362 {
44363 #if wxUSE_UNICODE
44364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44365 #else
44366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44367 #endif
44368 }
44369 return resultobj;
44370 fail:
44371 return NULL;
44372 }
44373
44374
44375 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44376 PyObject *resultobj = 0;
44377 wxControl *arg1 = (wxControl *) 0 ;
44378 wxCommandEvent *arg2 = 0 ;
44379 void *argp1 = 0 ;
44380 int res1 = 0 ;
44381 void *argp2 = 0 ;
44382 int res2 = 0 ;
44383 PyObject * obj0 = 0 ;
44384 PyObject * obj1 = 0 ;
44385 char * kwnames[] = {
44386 (char *) "self",(char *) "event", NULL
44387 };
44388
44389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44391 if (!SWIG_IsOK(res1)) {
44392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44393 }
44394 arg1 = reinterpret_cast< wxControl * >(argp1);
44395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44396 if (!SWIG_IsOK(res2)) {
44397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44398 }
44399 if (!argp2) {
44400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44401 }
44402 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44403 {
44404 PyThreadState* __tstate = wxPyBeginAllowThreads();
44405 (arg1)->Command(*arg2);
44406 wxPyEndAllowThreads(__tstate);
44407 if (PyErr_Occurred()) SWIG_fail;
44408 }
44409 resultobj = SWIG_Py_Void();
44410 return resultobj;
44411 fail:
44412 return NULL;
44413 }
44414
44415
44416 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44417 PyObject *resultobj = 0;
44418 wxControl *arg1 = (wxControl *) 0 ;
44419 wxString result;
44420 void *argp1 = 0 ;
44421 int res1 = 0 ;
44422 PyObject *swig_obj[1] ;
44423
44424 if (!args) SWIG_fail;
44425 swig_obj[0] = args;
44426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44427 if (!SWIG_IsOK(res1)) {
44428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44429 }
44430 arg1 = reinterpret_cast< wxControl * >(argp1);
44431 {
44432 PyThreadState* __tstate = wxPyBeginAllowThreads();
44433 result = (arg1)->GetLabel();
44434 wxPyEndAllowThreads(__tstate);
44435 if (PyErr_Occurred()) SWIG_fail;
44436 }
44437 {
44438 #if wxUSE_UNICODE
44439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44440 #else
44441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44442 #endif
44443 }
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44451 PyObject *resultobj = 0;
44452 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44453 SwigValueWrapper<wxVisualAttributes > result;
44454 int val1 ;
44455 int ecode1 = 0 ;
44456 PyObject * obj0 = 0 ;
44457 char * kwnames[] = {
44458 (char *) "variant", NULL
44459 };
44460
44461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44462 if (obj0) {
44463 ecode1 = SWIG_AsVal_int(obj0, &val1);
44464 if (!SWIG_IsOK(ecode1)) {
44465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44466 }
44467 arg1 = static_cast< wxWindowVariant >(val1);
44468 }
44469 {
44470 if (!wxPyCheckForApp()) SWIG_fail;
44471 PyThreadState* __tstate = wxPyBeginAllowThreads();
44472 result = wxControl::GetClassDefaultAttributes(arg1);
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44484 PyObject *obj;
44485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44486 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44487 return SWIG_Py_Void();
44488 }
44489
44490 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44491 return SWIG_Python_InitShadowInstance(args);
44492 }
44493
44494 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44495 PyObject *resultobj = 0;
44496 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44497 wxString *arg2 = 0 ;
44498 PyObject *arg3 = (PyObject *) NULL ;
44499 int result;
44500 void *argp1 = 0 ;
44501 int res1 = 0 ;
44502 bool temp2 = false ;
44503 PyObject * obj0 = 0 ;
44504 PyObject * obj1 = 0 ;
44505 PyObject * obj2 = 0 ;
44506 char * kwnames[] = {
44507 (char *) "self",(char *) "item",(char *) "clientData", NULL
44508 };
44509
44510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44512 if (!SWIG_IsOK(res1)) {
44513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44514 }
44515 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44516 {
44517 arg2 = wxString_in_helper(obj1);
44518 if (arg2 == NULL) SWIG_fail;
44519 temp2 = true;
44520 }
44521 if (obj2) {
44522 arg3 = obj2;
44523 }
44524 {
44525 PyThreadState* __tstate = wxPyBeginAllowThreads();
44526 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44527 wxPyEndAllowThreads(__tstate);
44528 if (PyErr_Occurred()) SWIG_fail;
44529 }
44530 resultobj = SWIG_From_int(static_cast< int >(result));
44531 {
44532 if (temp2)
44533 delete arg2;
44534 }
44535 return resultobj;
44536 fail:
44537 {
44538 if (temp2)
44539 delete arg2;
44540 }
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44546 PyObject *resultobj = 0;
44547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44548 wxArrayString *arg2 = 0 ;
44549 void *argp1 = 0 ;
44550 int res1 = 0 ;
44551 bool temp2 = false ;
44552 PyObject * obj0 = 0 ;
44553 PyObject * obj1 = 0 ;
44554 char * kwnames[] = {
44555 (char *) "self",(char *) "strings", NULL
44556 };
44557
44558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44560 if (!SWIG_IsOK(res1)) {
44561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44562 }
44563 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44564 {
44565 if (! PySequence_Check(obj1)) {
44566 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44567 SWIG_fail;
44568 }
44569 arg2 = new wxArrayString;
44570 temp2 = true;
44571 int i, len=PySequence_Length(obj1);
44572 for (i=0; i<len; i++) {
44573 PyObject* item = PySequence_GetItem(obj1, i);
44574 wxString* s = wxString_in_helper(item);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 arg2->Add(*s);
44577 delete s;
44578 Py_DECREF(item);
44579 }
44580 }
44581 {
44582 PyThreadState* __tstate = wxPyBeginAllowThreads();
44583 (arg1)->Append((wxArrayString const &)*arg2);
44584 wxPyEndAllowThreads(__tstate);
44585 if (PyErr_Occurred()) SWIG_fail;
44586 }
44587 resultobj = SWIG_Py_Void();
44588 {
44589 if (temp2) delete arg2;
44590 }
44591 return resultobj;
44592 fail:
44593 {
44594 if (temp2) delete arg2;
44595 }
44596 return NULL;
44597 }
44598
44599
44600 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44601 PyObject *resultobj = 0;
44602 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44603 wxString *arg2 = 0 ;
44604 unsigned int arg3 ;
44605 PyObject *arg4 = (PyObject *) NULL ;
44606 int result;
44607 void *argp1 = 0 ;
44608 int res1 = 0 ;
44609 bool temp2 = false ;
44610 unsigned int val3 ;
44611 int ecode3 = 0 ;
44612 PyObject * obj0 = 0 ;
44613 PyObject * obj1 = 0 ;
44614 PyObject * obj2 = 0 ;
44615 PyObject * obj3 = 0 ;
44616 char * kwnames[] = {
44617 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44618 };
44619
44620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44622 if (!SWIG_IsOK(res1)) {
44623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44624 }
44625 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44626 {
44627 arg2 = wxString_in_helper(obj1);
44628 if (arg2 == NULL) SWIG_fail;
44629 temp2 = true;
44630 }
44631 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44632 if (!SWIG_IsOK(ecode3)) {
44633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44634 }
44635 arg3 = static_cast< unsigned int >(val3);
44636 if (obj3) {
44637 arg4 = obj3;
44638 }
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 resultobj = SWIG_From_int(static_cast< int >(result));
44646 {
44647 if (temp2)
44648 delete arg2;
44649 }
44650 return resultobj;
44651 fail:
44652 {
44653 if (temp2)
44654 delete arg2;
44655 }
44656 return NULL;
44657 }
44658
44659
44660 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44661 PyObject *resultobj = 0;
44662 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44663 void *argp1 = 0 ;
44664 int res1 = 0 ;
44665 PyObject *swig_obj[1] ;
44666
44667 if (!args) SWIG_fail;
44668 swig_obj[0] = args;
44669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44670 if (!SWIG_IsOK(res1)) {
44671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44672 }
44673 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44674 {
44675 PyThreadState* __tstate = wxPyBeginAllowThreads();
44676 (arg1)->Clear();
44677 wxPyEndAllowThreads(__tstate);
44678 if (PyErr_Occurred()) SWIG_fail;
44679 }
44680 resultobj = SWIG_Py_Void();
44681 return resultobj;
44682 fail:
44683 return NULL;
44684 }
44685
44686
44687 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44688 PyObject *resultobj = 0;
44689 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44690 unsigned int arg2 ;
44691 void *argp1 = 0 ;
44692 int res1 = 0 ;
44693 unsigned int val2 ;
44694 int ecode2 = 0 ;
44695 PyObject * obj0 = 0 ;
44696 PyObject * obj1 = 0 ;
44697 char * kwnames[] = {
44698 (char *) "self",(char *) "n", NULL
44699 };
44700
44701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44703 if (!SWIG_IsOK(res1)) {
44704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44705 }
44706 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44707 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44708 if (!SWIG_IsOK(ecode2)) {
44709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44710 }
44711 arg2 = static_cast< unsigned int >(val2);
44712 {
44713 PyThreadState* __tstate = wxPyBeginAllowThreads();
44714 (arg1)->Delete(arg2);
44715 wxPyEndAllowThreads(__tstate);
44716 if (PyErr_Occurred()) SWIG_fail;
44717 }
44718 resultobj = SWIG_Py_Void();
44719 return resultobj;
44720 fail:
44721 return NULL;
44722 }
44723
44724
44725 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44726 PyObject *resultobj = 0;
44727 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44728 unsigned int arg2 ;
44729 PyObject *result = 0 ;
44730 void *argp1 = 0 ;
44731 int res1 = 0 ;
44732 unsigned int val2 ;
44733 int ecode2 = 0 ;
44734 PyObject * obj0 = 0 ;
44735 PyObject * obj1 = 0 ;
44736 char * kwnames[] = {
44737 (char *) "self",(char *) "n", NULL
44738 };
44739
44740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44742 if (!SWIG_IsOK(res1)) {
44743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44744 }
44745 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44746 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44747 if (!SWIG_IsOK(ecode2)) {
44748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44749 }
44750 arg2 = static_cast< unsigned int >(val2);
44751 {
44752 PyThreadState* __tstate = wxPyBeginAllowThreads();
44753 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44754 wxPyEndAllowThreads(__tstate);
44755 if (PyErr_Occurred()) SWIG_fail;
44756 }
44757 resultobj = result;
44758 return resultobj;
44759 fail:
44760 return NULL;
44761 }
44762
44763
44764 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44765 PyObject *resultobj = 0;
44766 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44767 unsigned int arg2 ;
44768 PyObject *arg3 = (PyObject *) 0 ;
44769 void *argp1 = 0 ;
44770 int res1 = 0 ;
44771 unsigned int val2 ;
44772 int ecode2 = 0 ;
44773 PyObject * obj0 = 0 ;
44774 PyObject * obj1 = 0 ;
44775 PyObject * obj2 = 0 ;
44776 char * kwnames[] = {
44777 (char *) "self",(char *) "n",(char *) "clientData", NULL
44778 };
44779
44780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44782 if (!SWIG_IsOK(res1)) {
44783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44784 }
44785 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44786 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44787 if (!SWIG_IsOK(ecode2)) {
44788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44789 }
44790 arg2 = static_cast< unsigned int >(val2);
44791 arg3 = obj2;
44792 {
44793 PyThreadState* __tstate = wxPyBeginAllowThreads();
44794 wxItemContainer_SetClientData(arg1,arg2,arg3);
44795 wxPyEndAllowThreads(__tstate);
44796 if (PyErr_Occurred()) SWIG_fail;
44797 }
44798 resultobj = SWIG_Py_Void();
44799 return resultobj;
44800 fail:
44801 return NULL;
44802 }
44803
44804
44805 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44806 PyObject *resultobj = 0;
44807 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44808 unsigned int result;
44809 void *argp1 = 0 ;
44810 int res1 = 0 ;
44811 PyObject *swig_obj[1] ;
44812
44813 if (!args) SWIG_fail;
44814 swig_obj[0] = args;
44815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44816 if (!SWIG_IsOK(res1)) {
44817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44818 }
44819 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44820 {
44821 PyThreadState* __tstate = wxPyBeginAllowThreads();
44822 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44823 wxPyEndAllowThreads(__tstate);
44824 if (PyErr_Occurred()) SWIG_fail;
44825 }
44826 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44827 return resultobj;
44828 fail:
44829 return NULL;
44830 }
44831
44832
44833 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44834 PyObject *resultobj = 0;
44835 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44836 bool result;
44837 void *argp1 = 0 ;
44838 int res1 = 0 ;
44839 PyObject *swig_obj[1] ;
44840
44841 if (!args) SWIG_fail;
44842 swig_obj[0] = args;
44843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44844 if (!SWIG_IsOK(res1)) {
44845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44846 }
44847 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44848 {
44849 PyThreadState* __tstate = wxPyBeginAllowThreads();
44850 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44851 wxPyEndAllowThreads(__tstate);
44852 if (PyErr_Occurred()) SWIG_fail;
44853 }
44854 {
44855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44856 }
44857 return resultobj;
44858 fail:
44859 return NULL;
44860 }
44861
44862
44863 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44864 PyObject *resultobj = 0;
44865 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44866 unsigned int arg2 ;
44867 wxString result;
44868 void *argp1 = 0 ;
44869 int res1 = 0 ;
44870 unsigned int val2 ;
44871 int ecode2 = 0 ;
44872 PyObject * obj0 = 0 ;
44873 PyObject * obj1 = 0 ;
44874 char * kwnames[] = {
44875 (char *) "self",(char *) "n", NULL
44876 };
44877
44878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44880 if (!SWIG_IsOK(res1)) {
44881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44882 }
44883 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44884 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44885 if (!SWIG_IsOK(ecode2)) {
44886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44887 }
44888 arg2 = static_cast< unsigned int >(val2);
44889 {
44890 PyThreadState* __tstate = wxPyBeginAllowThreads();
44891 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44892 wxPyEndAllowThreads(__tstate);
44893 if (PyErr_Occurred()) SWIG_fail;
44894 }
44895 {
44896 #if wxUSE_UNICODE
44897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44898 #else
44899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44900 #endif
44901 }
44902 return resultobj;
44903 fail:
44904 return NULL;
44905 }
44906
44907
44908 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44909 PyObject *resultobj = 0;
44910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44911 wxArrayString result;
44912 void *argp1 = 0 ;
44913 int res1 = 0 ;
44914 PyObject *swig_obj[1] ;
44915
44916 if (!args) SWIG_fail;
44917 swig_obj[0] = args;
44918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44919 if (!SWIG_IsOK(res1)) {
44920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44921 }
44922 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44923 {
44924 PyThreadState* __tstate = wxPyBeginAllowThreads();
44925 result = ((wxItemContainer const *)arg1)->GetStrings();
44926 wxPyEndAllowThreads(__tstate);
44927 if (PyErr_Occurred()) SWIG_fail;
44928 }
44929 {
44930 resultobj = wxArrayString2PyList_helper(result);
44931 }
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj = 0;
44940 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44941 unsigned int arg2 ;
44942 wxString *arg3 = 0 ;
44943 void *argp1 = 0 ;
44944 int res1 = 0 ;
44945 unsigned int val2 ;
44946 int ecode2 = 0 ;
44947 bool temp3 = false ;
44948 PyObject * obj0 = 0 ;
44949 PyObject * obj1 = 0 ;
44950 PyObject * obj2 = 0 ;
44951 char * kwnames[] = {
44952 (char *) "self",(char *) "n",(char *) "s", NULL
44953 };
44954
44955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44957 if (!SWIG_IsOK(res1)) {
44958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44959 }
44960 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44961 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44962 if (!SWIG_IsOK(ecode2)) {
44963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44964 }
44965 arg2 = static_cast< unsigned int >(val2);
44966 {
44967 arg3 = wxString_in_helper(obj2);
44968 if (arg3 == NULL) SWIG_fail;
44969 temp3 = true;
44970 }
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 (arg1)->SetString(arg2,(wxString const &)*arg3);
44974 wxPyEndAllowThreads(__tstate);
44975 if (PyErr_Occurred()) SWIG_fail;
44976 }
44977 resultobj = SWIG_Py_Void();
44978 {
44979 if (temp3)
44980 delete arg3;
44981 }
44982 return resultobj;
44983 fail:
44984 {
44985 if (temp3)
44986 delete arg3;
44987 }
44988 return NULL;
44989 }
44990
44991
44992 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44993 PyObject *resultobj = 0;
44994 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44995 wxString *arg2 = 0 ;
44996 int result;
44997 void *argp1 = 0 ;
44998 int res1 = 0 ;
44999 bool temp2 = false ;
45000 PyObject * obj0 = 0 ;
45001 PyObject * obj1 = 0 ;
45002 char * kwnames[] = {
45003 (char *) "self",(char *) "s", NULL
45004 };
45005
45006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45008 if (!SWIG_IsOK(res1)) {
45009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45010 }
45011 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45012 {
45013 arg2 = wxString_in_helper(obj1);
45014 if (arg2 == NULL) SWIG_fail;
45015 temp2 = true;
45016 }
45017 {
45018 PyThreadState* __tstate = wxPyBeginAllowThreads();
45019 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45020 wxPyEndAllowThreads(__tstate);
45021 if (PyErr_Occurred()) SWIG_fail;
45022 }
45023 resultobj = SWIG_From_int(static_cast< int >(result));
45024 {
45025 if (temp2)
45026 delete arg2;
45027 }
45028 return resultobj;
45029 fail:
45030 {
45031 if (temp2)
45032 delete arg2;
45033 }
45034 return NULL;
45035 }
45036
45037
45038 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45039 PyObject *resultobj = 0;
45040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45041 int arg2 ;
45042 void *argp1 = 0 ;
45043 int res1 = 0 ;
45044 int val2 ;
45045 int ecode2 = 0 ;
45046 PyObject * obj0 = 0 ;
45047 PyObject * obj1 = 0 ;
45048 char * kwnames[] = {
45049 (char *) "self",(char *) "n", NULL
45050 };
45051
45052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45054 if (!SWIG_IsOK(res1)) {
45055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45056 }
45057 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45058 ecode2 = SWIG_AsVal_int(obj1, &val2);
45059 if (!SWIG_IsOK(ecode2)) {
45060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45061 }
45062 arg2 = static_cast< int >(val2);
45063 {
45064 PyThreadState* __tstate = wxPyBeginAllowThreads();
45065 (arg1)->SetSelection(arg2);
45066 wxPyEndAllowThreads(__tstate);
45067 if (PyErr_Occurred()) SWIG_fail;
45068 }
45069 resultobj = SWIG_Py_Void();
45070 return resultobj;
45071 fail:
45072 return NULL;
45073 }
45074
45075
45076 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45077 PyObject *resultobj = 0;
45078 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45079 int result;
45080 void *argp1 = 0 ;
45081 int res1 = 0 ;
45082 PyObject *swig_obj[1] ;
45083
45084 if (!args) SWIG_fail;
45085 swig_obj[0] = args;
45086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45087 if (!SWIG_IsOK(res1)) {
45088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45089 }
45090 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45091 {
45092 PyThreadState* __tstate = wxPyBeginAllowThreads();
45093 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45094 wxPyEndAllowThreads(__tstate);
45095 if (PyErr_Occurred()) SWIG_fail;
45096 }
45097 resultobj = SWIG_From_int(static_cast< int >(result));
45098 return resultobj;
45099 fail:
45100 return NULL;
45101 }
45102
45103
45104 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45105 PyObject *resultobj = 0;
45106 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45107 wxString *arg2 = 0 ;
45108 bool result;
45109 void *argp1 = 0 ;
45110 int res1 = 0 ;
45111 bool temp2 = false ;
45112 PyObject * obj0 = 0 ;
45113 PyObject * obj1 = 0 ;
45114 char * kwnames[] = {
45115 (char *) "self",(char *) "s", NULL
45116 };
45117
45118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45120 if (!SWIG_IsOK(res1)) {
45121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45122 }
45123 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45124 {
45125 arg2 = wxString_in_helper(obj1);
45126 if (arg2 == NULL) SWIG_fail;
45127 temp2 = true;
45128 }
45129 {
45130 PyThreadState* __tstate = wxPyBeginAllowThreads();
45131 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45132 wxPyEndAllowThreads(__tstate);
45133 if (PyErr_Occurred()) SWIG_fail;
45134 }
45135 {
45136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45137 }
45138 {
45139 if (temp2)
45140 delete arg2;
45141 }
45142 return resultobj;
45143 fail:
45144 {
45145 if (temp2)
45146 delete arg2;
45147 }
45148 return NULL;
45149 }
45150
45151
45152 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45153 PyObject *resultobj = 0;
45154 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45155 wxString result;
45156 void *argp1 = 0 ;
45157 int res1 = 0 ;
45158 PyObject *swig_obj[1] ;
45159
45160 if (!args) SWIG_fail;
45161 swig_obj[0] = args;
45162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45163 if (!SWIG_IsOK(res1)) {
45164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45165 }
45166 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45167 {
45168 PyThreadState* __tstate = wxPyBeginAllowThreads();
45169 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45170 wxPyEndAllowThreads(__tstate);
45171 if (PyErr_Occurred()) SWIG_fail;
45172 }
45173 {
45174 #if wxUSE_UNICODE
45175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45176 #else
45177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45178 #endif
45179 }
45180 return resultobj;
45181 fail:
45182 return NULL;
45183 }
45184
45185
45186 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45187 PyObject *resultobj = 0;
45188 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45189 int arg2 ;
45190 void *argp1 = 0 ;
45191 int res1 = 0 ;
45192 int val2 ;
45193 int ecode2 = 0 ;
45194 PyObject * obj0 = 0 ;
45195 PyObject * obj1 = 0 ;
45196 char * kwnames[] = {
45197 (char *) "self",(char *) "n", NULL
45198 };
45199
45200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45202 if (!SWIG_IsOK(res1)) {
45203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45204 }
45205 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45206 ecode2 = SWIG_AsVal_int(obj1, &val2);
45207 if (!SWIG_IsOK(ecode2)) {
45208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45209 }
45210 arg2 = static_cast< int >(val2);
45211 {
45212 PyThreadState* __tstate = wxPyBeginAllowThreads();
45213 (arg1)->Select(arg2);
45214 wxPyEndAllowThreads(__tstate);
45215 if (PyErr_Occurred()) SWIG_fail;
45216 }
45217 resultobj = SWIG_Py_Void();
45218 return resultobj;
45219 fail:
45220 return NULL;
45221 }
45222
45223
45224 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45225 PyObject *obj;
45226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45227 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45228 return SWIG_Py_Void();
45229 }
45230
45231 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45232 PyObject *obj;
45233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45234 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45235 return SWIG_Py_Void();
45236 }
45237
45238 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45239 PyObject *resultobj = 0;
45240 wxSizerItem *result = 0 ;
45241
45242 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45243 {
45244 PyThreadState* __tstate = wxPyBeginAllowThreads();
45245 result = (wxSizerItem *)new wxSizerItem();
45246 wxPyEndAllowThreads(__tstate);
45247 if (PyErr_Occurred()) SWIG_fail;
45248 }
45249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45250 return resultobj;
45251 fail:
45252 return NULL;
45253 }
45254
45255
45256 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45257 PyObject *resultobj = 0;
45258 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45259 void *argp1 = 0 ;
45260 int res1 = 0 ;
45261 PyObject *swig_obj[1] ;
45262
45263 if (!args) SWIG_fail;
45264 swig_obj[0] = args;
45265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45266 if (!SWIG_IsOK(res1)) {
45267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45268 }
45269 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45270 {
45271 PyThreadState* __tstate = wxPyBeginAllowThreads();
45272 delete arg1;
45273
45274 wxPyEndAllowThreads(__tstate);
45275 if (PyErr_Occurred()) SWIG_fail;
45276 }
45277 resultobj = SWIG_Py_Void();
45278 return resultobj;
45279 fail:
45280 return NULL;
45281 }
45282
45283
45284 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45285 PyObject *resultobj = 0;
45286 wxWindow *arg1 = (wxWindow *) 0 ;
45287 int arg2 ;
45288 int arg3 ;
45289 int arg4 ;
45290 PyObject *arg5 = (PyObject *) NULL ;
45291 wxSizerItem *result = 0 ;
45292 void *argp1 = 0 ;
45293 int res1 = 0 ;
45294 int val2 ;
45295 int ecode2 = 0 ;
45296 int val3 ;
45297 int ecode3 = 0 ;
45298 int val4 ;
45299 int ecode4 = 0 ;
45300 PyObject * obj0 = 0 ;
45301 PyObject * obj1 = 0 ;
45302 PyObject * obj2 = 0 ;
45303 PyObject * obj3 = 0 ;
45304 PyObject * obj4 = 0 ;
45305 char * kwnames[] = {
45306 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45307 };
45308
45309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45311 if (!SWIG_IsOK(res1)) {
45312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45313 }
45314 arg1 = reinterpret_cast< wxWindow * >(argp1);
45315 ecode2 = SWIG_AsVal_int(obj1, &val2);
45316 if (!SWIG_IsOK(ecode2)) {
45317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45318 }
45319 arg2 = static_cast< int >(val2);
45320 ecode3 = SWIG_AsVal_int(obj2, &val3);
45321 if (!SWIG_IsOK(ecode3)) {
45322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45323 }
45324 arg3 = static_cast< int >(val3);
45325 ecode4 = SWIG_AsVal_int(obj3, &val4);
45326 if (!SWIG_IsOK(ecode4)) {
45327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45328 }
45329 arg4 = static_cast< int >(val4);
45330 if (obj4) {
45331 arg5 = obj4;
45332 }
45333 {
45334 PyThreadState* __tstate = wxPyBeginAllowThreads();
45335 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45340 return resultobj;
45341 fail:
45342 return NULL;
45343 }
45344
45345
45346 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45347 PyObject *resultobj = 0;
45348 int arg1 ;
45349 int arg2 ;
45350 int arg3 ;
45351 int arg4 ;
45352 int arg5 ;
45353 PyObject *arg6 = (PyObject *) NULL ;
45354 wxSizerItem *result = 0 ;
45355 int val1 ;
45356 int ecode1 = 0 ;
45357 int val2 ;
45358 int ecode2 = 0 ;
45359 int val3 ;
45360 int ecode3 = 0 ;
45361 int val4 ;
45362 int ecode4 = 0 ;
45363 int val5 ;
45364 int ecode5 = 0 ;
45365 PyObject * obj0 = 0 ;
45366 PyObject * obj1 = 0 ;
45367 PyObject * obj2 = 0 ;
45368 PyObject * obj3 = 0 ;
45369 PyObject * obj4 = 0 ;
45370 PyObject * obj5 = 0 ;
45371 char * kwnames[] = {
45372 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45373 };
45374
45375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45376 ecode1 = SWIG_AsVal_int(obj0, &val1);
45377 if (!SWIG_IsOK(ecode1)) {
45378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45379 }
45380 arg1 = static_cast< int >(val1);
45381 ecode2 = SWIG_AsVal_int(obj1, &val2);
45382 if (!SWIG_IsOK(ecode2)) {
45383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45384 }
45385 arg2 = static_cast< int >(val2);
45386 ecode3 = SWIG_AsVal_int(obj2, &val3);
45387 if (!SWIG_IsOK(ecode3)) {
45388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45389 }
45390 arg3 = static_cast< int >(val3);
45391 ecode4 = SWIG_AsVal_int(obj3, &val4);
45392 if (!SWIG_IsOK(ecode4)) {
45393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45394 }
45395 arg4 = static_cast< int >(val4);
45396 ecode5 = SWIG_AsVal_int(obj4, &val5);
45397 if (!SWIG_IsOK(ecode5)) {
45398 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45399 }
45400 arg5 = static_cast< int >(val5);
45401 if (obj5) {
45402 arg6 = obj5;
45403 }
45404 {
45405 PyThreadState* __tstate = wxPyBeginAllowThreads();
45406 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45407 wxPyEndAllowThreads(__tstate);
45408 if (PyErr_Occurred()) SWIG_fail;
45409 }
45410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45411 return resultobj;
45412 fail:
45413 return NULL;
45414 }
45415
45416
45417 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45418 PyObject *resultobj = 0;
45419 wxSizer *arg1 = (wxSizer *) 0 ;
45420 int arg2 ;
45421 int arg3 ;
45422 int arg4 ;
45423 PyObject *arg5 = (PyObject *) NULL ;
45424 wxSizerItem *result = 0 ;
45425 int res1 = 0 ;
45426 int val2 ;
45427 int ecode2 = 0 ;
45428 int val3 ;
45429 int ecode3 = 0 ;
45430 int val4 ;
45431 int ecode4 = 0 ;
45432 PyObject * obj0 = 0 ;
45433 PyObject * obj1 = 0 ;
45434 PyObject * obj2 = 0 ;
45435 PyObject * obj3 = 0 ;
45436 PyObject * obj4 = 0 ;
45437 char * kwnames[] = {
45438 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45439 };
45440
45441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45442 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45443 if (!SWIG_IsOK(res1)) {
45444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45445 }
45446 ecode2 = SWIG_AsVal_int(obj1, &val2);
45447 if (!SWIG_IsOK(ecode2)) {
45448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45449 }
45450 arg2 = static_cast< int >(val2);
45451 ecode3 = SWIG_AsVal_int(obj2, &val3);
45452 if (!SWIG_IsOK(ecode3)) {
45453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45454 }
45455 arg3 = static_cast< int >(val3);
45456 ecode4 = SWIG_AsVal_int(obj3, &val4);
45457 if (!SWIG_IsOK(ecode4)) {
45458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45459 }
45460 arg4 = static_cast< int >(val4);
45461 if (obj4) {
45462 arg5 = obj4;
45463 }
45464 {
45465 PyThreadState* __tstate = wxPyBeginAllowThreads();
45466 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45467 wxPyEndAllowThreads(__tstate);
45468 if (PyErr_Occurred()) SWIG_fail;
45469 }
45470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45471 return resultobj;
45472 fail:
45473 return NULL;
45474 }
45475
45476
45477 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45478 PyObject *resultobj = 0;
45479 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45480 void *argp1 = 0 ;
45481 int res1 = 0 ;
45482 PyObject *swig_obj[1] ;
45483
45484 if (!args) SWIG_fail;
45485 swig_obj[0] = args;
45486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45487 if (!SWIG_IsOK(res1)) {
45488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45489 }
45490 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45491 {
45492 PyThreadState* __tstate = wxPyBeginAllowThreads();
45493 (arg1)->DeleteWindows();
45494 wxPyEndAllowThreads(__tstate);
45495 if (PyErr_Occurred()) SWIG_fail;
45496 }
45497 resultobj = SWIG_Py_Void();
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45505 PyObject *resultobj = 0;
45506 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45507 void *argp1 = 0 ;
45508 int res1 = 0 ;
45509 PyObject *swig_obj[1] ;
45510
45511 if (!args) SWIG_fail;
45512 swig_obj[0] = args;
45513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45516 }
45517 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45518 {
45519 PyThreadState* __tstate = wxPyBeginAllowThreads();
45520 (arg1)->DetachSizer();
45521 wxPyEndAllowThreads(__tstate);
45522 if (PyErr_Occurred()) SWIG_fail;
45523 }
45524 resultobj = SWIG_Py_Void();
45525 return resultobj;
45526 fail:
45527 return NULL;
45528 }
45529
45530
45531 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45532 PyObject *resultobj = 0;
45533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45534 wxSize result;
45535 void *argp1 = 0 ;
45536 int res1 = 0 ;
45537 PyObject *swig_obj[1] ;
45538
45539 if (!args) SWIG_fail;
45540 swig_obj[0] = args;
45541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45542 if (!SWIG_IsOK(res1)) {
45543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45544 }
45545 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45546 {
45547 PyThreadState* __tstate = wxPyBeginAllowThreads();
45548 result = (arg1)->GetSize();
45549 wxPyEndAllowThreads(__tstate);
45550 if (PyErr_Occurred()) SWIG_fail;
45551 }
45552 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45553 return resultobj;
45554 fail:
45555 return NULL;
45556 }
45557
45558
45559 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45560 PyObject *resultobj = 0;
45561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45562 wxSize result;
45563 void *argp1 = 0 ;
45564 int res1 = 0 ;
45565 PyObject *swig_obj[1] ;
45566
45567 if (!args) SWIG_fail;
45568 swig_obj[0] = args;
45569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45570 if (!SWIG_IsOK(res1)) {
45571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45572 }
45573 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45574 {
45575 PyThreadState* __tstate = wxPyBeginAllowThreads();
45576 result = (arg1)->CalcMin();
45577 wxPyEndAllowThreads(__tstate);
45578 if (PyErr_Occurred()) SWIG_fail;
45579 }
45580 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45581 return resultobj;
45582 fail:
45583 return NULL;
45584 }
45585
45586
45587 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45588 PyObject *resultobj = 0;
45589 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45590 wxPoint *arg2 = 0 ;
45591 wxSize *arg3 = 0 ;
45592 void *argp1 = 0 ;
45593 int res1 = 0 ;
45594 wxPoint temp2 ;
45595 wxSize temp3 ;
45596 PyObject * obj0 = 0 ;
45597 PyObject * obj1 = 0 ;
45598 PyObject * obj2 = 0 ;
45599 char * kwnames[] = {
45600 (char *) "self",(char *) "pos",(char *) "size", NULL
45601 };
45602
45603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45605 if (!SWIG_IsOK(res1)) {
45606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45607 }
45608 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45609 {
45610 arg2 = &temp2;
45611 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45612 }
45613 {
45614 arg3 = &temp3;
45615 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45616 }
45617 {
45618 PyThreadState* __tstate = wxPyBeginAllowThreads();
45619 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45620 wxPyEndAllowThreads(__tstate);
45621 if (PyErr_Occurred()) SWIG_fail;
45622 }
45623 resultobj = SWIG_Py_Void();
45624 return resultobj;
45625 fail:
45626 return NULL;
45627 }
45628
45629
45630 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45631 PyObject *resultobj = 0;
45632 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45633 wxSize result;
45634 void *argp1 = 0 ;
45635 int res1 = 0 ;
45636 PyObject *swig_obj[1] ;
45637
45638 if (!args) SWIG_fail;
45639 swig_obj[0] = args;
45640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45641 if (!SWIG_IsOK(res1)) {
45642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45643 }
45644 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45645 {
45646 PyThreadState* __tstate = wxPyBeginAllowThreads();
45647 result = (arg1)->GetMinSize();
45648 wxPyEndAllowThreads(__tstate);
45649 if (PyErr_Occurred()) SWIG_fail;
45650 }
45651 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45652 return resultobj;
45653 fail:
45654 return NULL;
45655 }
45656
45657
45658 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45659 PyObject *resultobj = 0;
45660 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45661 wxSize result;
45662 void *argp1 = 0 ;
45663 int res1 = 0 ;
45664 PyObject *swig_obj[1] ;
45665
45666 if (!args) SWIG_fail;
45667 swig_obj[0] = args;
45668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45669 if (!SWIG_IsOK(res1)) {
45670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45671 }
45672 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45673 {
45674 PyThreadState* __tstate = wxPyBeginAllowThreads();
45675 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45676 wxPyEndAllowThreads(__tstate);
45677 if (PyErr_Occurred()) SWIG_fail;
45678 }
45679 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45680 return resultobj;
45681 fail:
45682 return NULL;
45683 }
45684
45685
45686 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45687 PyObject *resultobj = 0;
45688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45689 int arg2 ;
45690 int arg3 ;
45691 void *argp1 = 0 ;
45692 int res1 = 0 ;
45693 int val2 ;
45694 int ecode2 = 0 ;
45695 int val3 ;
45696 int ecode3 = 0 ;
45697 PyObject * obj0 = 0 ;
45698 PyObject * obj1 = 0 ;
45699 PyObject * obj2 = 0 ;
45700 char * kwnames[] = {
45701 (char *) "self",(char *) "x",(char *) "y", NULL
45702 };
45703
45704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45706 if (!SWIG_IsOK(res1)) {
45707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45708 }
45709 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45710 ecode2 = SWIG_AsVal_int(obj1, &val2);
45711 if (!SWIG_IsOK(ecode2)) {
45712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45713 }
45714 arg2 = static_cast< int >(val2);
45715 ecode3 = SWIG_AsVal_int(obj2, &val3);
45716 if (!SWIG_IsOK(ecode3)) {
45717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45718 }
45719 arg3 = static_cast< int >(val3);
45720 {
45721 PyThreadState* __tstate = wxPyBeginAllowThreads();
45722 (arg1)->SetInitSize(arg2,arg3);
45723 wxPyEndAllowThreads(__tstate);
45724 if (PyErr_Occurred()) SWIG_fail;
45725 }
45726 resultobj = SWIG_Py_Void();
45727 return resultobj;
45728 fail:
45729 return NULL;
45730 }
45731
45732
45733 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45734 PyObject *resultobj = 0;
45735 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45736 int arg2 ;
45737 int arg3 ;
45738 void *argp1 = 0 ;
45739 int res1 = 0 ;
45740 int val2 ;
45741 int ecode2 = 0 ;
45742 int val3 ;
45743 int ecode3 = 0 ;
45744 PyObject * obj0 = 0 ;
45745 PyObject * obj1 = 0 ;
45746 PyObject * obj2 = 0 ;
45747 char * kwnames[] = {
45748 (char *) "self",(char *) "width",(char *) "height", NULL
45749 };
45750
45751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45753 if (!SWIG_IsOK(res1)) {
45754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45755 }
45756 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45757 ecode2 = SWIG_AsVal_int(obj1, &val2);
45758 if (!SWIG_IsOK(ecode2)) {
45759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45760 }
45761 arg2 = static_cast< int >(val2);
45762 ecode3 = SWIG_AsVal_int(obj2, &val3);
45763 if (!SWIG_IsOK(ecode3)) {
45764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45765 }
45766 arg3 = static_cast< int >(val3);
45767 {
45768 PyThreadState* __tstate = wxPyBeginAllowThreads();
45769 (arg1)->SetRatio(arg2,arg3);
45770 wxPyEndAllowThreads(__tstate);
45771 if (PyErr_Occurred()) SWIG_fail;
45772 }
45773 resultobj = SWIG_Py_Void();
45774 return resultobj;
45775 fail:
45776 return NULL;
45777 }
45778
45779
45780 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45781 PyObject *resultobj = 0;
45782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45783 wxSize *arg2 = 0 ;
45784 void *argp1 = 0 ;
45785 int res1 = 0 ;
45786 wxSize temp2 ;
45787 PyObject * obj0 = 0 ;
45788 PyObject * obj1 = 0 ;
45789 char * kwnames[] = {
45790 (char *) "self",(char *) "size", NULL
45791 };
45792
45793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45795 if (!SWIG_IsOK(res1)) {
45796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45797 }
45798 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45799 {
45800 arg2 = &temp2;
45801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45802 }
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 (arg1)->SetRatio((wxSize const &)*arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = SWIG_Py_Void();
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45817 PyObject *resultobj = 0;
45818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45819 float arg2 ;
45820 void *argp1 = 0 ;
45821 int res1 = 0 ;
45822 float val2 ;
45823 int ecode2 = 0 ;
45824 PyObject * obj0 = 0 ;
45825 PyObject * obj1 = 0 ;
45826 char * kwnames[] = {
45827 (char *) "self",(char *) "ratio", NULL
45828 };
45829
45830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45832 if (!SWIG_IsOK(res1)) {
45833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45834 }
45835 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45836 ecode2 = SWIG_AsVal_float(obj1, &val2);
45837 if (!SWIG_IsOK(ecode2)) {
45838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45839 }
45840 arg2 = static_cast< float >(val2);
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 (arg1)->SetRatio(arg2);
45844 wxPyEndAllowThreads(__tstate);
45845 if (PyErr_Occurred()) SWIG_fail;
45846 }
45847 resultobj = SWIG_Py_Void();
45848 return resultobj;
45849 fail:
45850 return NULL;
45851 }
45852
45853
45854 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45855 PyObject *resultobj = 0;
45856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45857 float result;
45858 void *argp1 = 0 ;
45859 int res1 = 0 ;
45860 PyObject *swig_obj[1] ;
45861
45862 if (!args) SWIG_fail;
45863 swig_obj[0] = args;
45864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45865 if (!SWIG_IsOK(res1)) {
45866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45867 }
45868 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 result = (float)(arg1)->GetRatio();
45872 wxPyEndAllowThreads(__tstate);
45873 if (PyErr_Occurred()) SWIG_fail;
45874 }
45875 resultobj = SWIG_From_float(static_cast< float >(result));
45876 return resultobj;
45877 fail:
45878 return NULL;
45879 }
45880
45881
45882 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45883 PyObject *resultobj = 0;
45884 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45885 wxRect result;
45886 void *argp1 = 0 ;
45887 int res1 = 0 ;
45888 PyObject *swig_obj[1] ;
45889
45890 if (!args) SWIG_fail;
45891 swig_obj[0] = args;
45892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45893 if (!SWIG_IsOK(res1)) {
45894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45895 }
45896 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 result = (arg1)->GetRect();
45900 wxPyEndAllowThreads(__tstate);
45901 if (PyErr_Occurred()) SWIG_fail;
45902 }
45903 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45911 PyObject *resultobj = 0;
45912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45913 bool result;
45914 void *argp1 = 0 ;
45915 int res1 = 0 ;
45916 PyObject *swig_obj[1] ;
45917
45918 if (!args) SWIG_fail;
45919 swig_obj[0] = args;
45920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45921 if (!SWIG_IsOK(res1)) {
45922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45923 }
45924 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45925 {
45926 PyThreadState* __tstate = wxPyBeginAllowThreads();
45927 result = (bool)(arg1)->IsWindow();
45928 wxPyEndAllowThreads(__tstate);
45929 if (PyErr_Occurred()) SWIG_fail;
45930 }
45931 {
45932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45933 }
45934 return resultobj;
45935 fail:
45936 return NULL;
45937 }
45938
45939
45940 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45941 PyObject *resultobj = 0;
45942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45943 bool result;
45944 void *argp1 = 0 ;
45945 int res1 = 0 ;
45946 PyObject *swig_obj[1] ;
45947
45948 if (!args) SWIG_fail;
45949 swig_obj[0] = args;
45950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45951 if (!SWIG_IsOK(res1)) {
45952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45953 }
45954 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45955 {
45956 PyThreadState* __tstate = wxPyBeginAllowThreads();
45957 result = (bool)(arg1)->IsSizer();
45958 wxPyEndAllowThreads(__tstate);
45959 if (PyErr_Occurred()) SWIG_fail;
45960 }
45961 {
45962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45963 }
45964 return resultobj;
45965 fail:
45966 return NULL;
45967 }
45968
45969
45970 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45971 PyObject *resultobj = 0;
45972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45973 bool result;
45974 void *argp1 = 0 ;
45975 int res1 = 0 ;
45976 PyObject *swig_obj[1] ;
45977
45978 if (!args) SWIG_fail;
45979 swig_obj[0] = args;
45980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45981 if (!SWIG_IsOK(res1)) {
45982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45983 }
45984 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45985 {
45986 PyThreadState* __tstate = wxPyBeginAllowThreads();
45987 result = (bool)(arg1)->IsSpacer();
45988 wxPyEndAllowThreads(__tstate);
45989 if (PyErr_Occurred()) SWIG_fail;
45990 }
45991 {
45992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45993 }
45994 return resultobj;
45995 fail:
45996 return NULL;
45997 }
45998
45999
46000 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46001 PyObject *resultobj = 0;
46002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46003 int arg2 ;
46004 void *argp1 = 0 ;
46005 int res1 = 0 ;
46006 int val2 ;
46007 int ecode2 = 0 ;
46008 PyObject * obj0 = 0 ;
46009 PyObject * obj1 = 0 ;
46010 char * kwnames[] = {
46011 (char *) "self",(char *) "proportion", NULL
46012 };
46013
46014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46016 if (!SWIG_IsOK(res1)) {
46017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46018 }
46019 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46020 ecode2 = SWIG_AsVal_int(obj1, &val2);
46021 if (!SWIG_IsOK(ecode2)) {
46022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46023 }
46024 arg2 = static_cast< int >(val2);
46025 {
46026 PyThreadState* __tstate = wxPyBeginAllowThreads();
46027 (arg1)->SetProportion(arg2);
46028 wxPyEndAllowThreads(__tstate);
46029 if (PyErr_Occurred()) SWIG_fail;
46030 }
46031 resultobj = SWIG_Py_Void();
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46039 PyObject *resultobj = 0;
46040 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46041 int result;
46042 void *argp1 = 0 ;
46043 int res1 = 0 ;
46044 PyObject *swig_obj[1] ;
46045
46046 if (!args) SWIG_fail;
46047 swig_obj[0] = args;
46048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46049 if (!SWIG_IsOK(res1)) {
46050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46051 }
46052 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46053 {
46054 PyThreadState* __tstate = wxPyBeginAllowThreads();
46055 result = (int)(arg1)->GetProportion();
46056 wxPyEndAllowThreads(__tstate);
46057 if (PyErr_Occurred()) SWIG_fail;
46058 }
46059 resultobj = SWIG_From_int(static_cast< int >(result));
46060 return resultobj;
46061 fail:
46062 return NULL;
46063 }
46064
46065
46066 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46067 PyObject *resultobj = 0;
46068 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46069 int arg2 ;
46070 void *argp1 = 0 ;
46071 int res1 = 0 ;
46072 int val2 ;
46073 int ecode2 = 0 ;
46074 PyObject * obj0 = 0 ;
46075 PyObject * obj1 = 0 ;
46076 char * kwnames[] = {
46077 (char *) "self",(char *) "flag", NULL
46078 };
46079
46080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46082 if (!SWIG_IsOK(res1)) {
46083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46084 }
46085 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46086 ecode2 = SWIG_AsVal_int(obj1, &val2);
46087 if (!SWIG_IsOK(ecode2)) {
46088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46089 }
46090 arg2 = static_cast< int >(val2);
46091 {
46092 PyThreadState* __tstate = wxPyBeginAllowThreads();
46093 (arg1)->SetFlag(arg2);
46094 wxPyEndAllowThreads(__tstate);
46095 if (PyErr_Occurred()) SWIG_fail;
46096 }
46097 resultobj = SWIG_Py_Void();
46098 return resultobj;
46099 fail:
46100 return NULL;
46101 }
46102
46103
46104 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46105 PyObject *resultobj = 0;
46106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46107 int result;
46108 void *argp1 = 0 ;
46109 int res1 = 0 ;
46110 PyObject *swig_obj[1] ;
46111
46112 if (!args) SWIG_fail;
46113 swig_obj[0] = args;
46114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46115 if (!SWIG_IsOK(res1)) {
46116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46117 }
46118 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46119 {
46120 PyThreadState* __tstate = wxPyBeginAllowThreads();
46121 result = (int)(arg1)->GetFlag();
46122 wxPyEndAllowThreads(__tstate);
46123 if (PyErr_Occurred()) SWIG_fail;
46124 }
46125 resultobj = SWIG_From_int(static_cast< int >(result));
46126 return resultobj;
46127 fail:
46128 return NULL;
46129 }
46130
46131
46132 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46133 PyObject *resultobj = 0;
46134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46135 int arg2 ;
46136 void *argp1 = 0 ;
46137 int res1 = 0 ;
46138 int val2 ;
46139 int ecode2 = 0 ;
46140 PyObject * obj0 = 0 ;
46141 PyObject * obj1 = 0 ;
46142 char * kwnames[] = {
46143 (char *) "self",(char *) "border", NULL
46144 };
46145
46146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46148 if (!SWIG_IsOK(res1)) {
46149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46150 }
46151 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46152 ecode2 = SWIG_AsVal_int(obj1, &val2);
46153 if (!SWIG_IsOK(ecode2)) {
46154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46155 }
46156 arg2 = static_cast< int >(val2);
46157 {
46158 PyThreadState* __tstate = wxPyBeginAllowThreads();
46159 (arg1)->SetBorder(arg2);
46160 wxPyEndAllowThreads(__tstate);
46161 if (PyErr_Occurred()) SWIG_fail;
46162 }
46163 resultobj = SWIG_Py_Void();
46164 return resultobj;
46165 fail:
46166 return NULL;
46167 }
46168
46169
46170 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46171 PyObject *resultobj = 0;
46172 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46173 int result;
46174 void *argp1 = 0 ;
46175 int res1 = 0 ;
46176 PyObject *swig_obj[1] ;
46177
46178 if (!args) SWIG_fail;
46179 swig_obj[0] = args;
46180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46181 if (!SWIG_IsOK(res1)) {
46182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46183 }
46184 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46185 {
46186 PyThreadState* __tstate = wxPyBeginAllowThreads();
46187 result = (int)(arg1)->GetBorder();
46188 wxPyEndAllowThreads(__tstate);
46189 if (PyErr_Occurred()) SWIG_fail;
46190 }
46191 resultobj = SWIG_From_int(static_cast< int >(result));
46192 return resultobj;
46193 fail:
46194 return NULL;
46195 }
46196
46197
46198 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46199 PyObject *resultobj = 0;
46200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46201 wxWindow *result = 0 ;
46202 void *argp1 = 0 ;
46203 int res1 = 0 ;
46204 PyObject *swig_obj[1] ;
46205
46206 if (!args) SWIG_fail;
46207 swig_obj[0] = args;
46208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46209 if (!SWIG_IsOK(res1)) {
46210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46211 }
46212 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46213 {
46214 PyThreadState* __tstate = wxPyBeginAllowThreads();
46215 result = (wxWindow *)(arg1)->GetWindow();
46216 wxPyEndAllowThreads(__tstate);
46217 if (PyErr_Occurred()) SWIG_fail;
46218 }
46219 {
46220 resultobj = wxPyMake_wxObject(result, 0);
46221 }
46222 return resultobj;
46223 fail:
46224 return NULL;
46225 }
46226
46227
46228 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46229 PyObject *resultobj = 0;
46230 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46231 wxWindow *arg2 = (wxWindow *) 0 ;
46232 void *argp1 = 0 ;
46233 int res1 = 0 ;
46234 void *argp2 = 0 ;
46235 int res2 = 0 ;
46236 PyObject * obj0 = 0 ;
46237 PyObject * obj1 = 0 ;
46238 char * kwnames[] = {
46239 (char *) "self",(char *) "window", NULL
46240 };
46241
46242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46244 if (!SWIG_IsOK(res1)) {
46245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46246 }
46247 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46249 if (!SWIG_IsOK(res2)) {
46250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46251 }
46252 arg2 = reinterpret_cast< wxWindow * >(argp2);
46253 {
46254 PyThreadState* __tstate = wxPyBeginAllowThreads();
46255 (arg1)->SetWindow(arg2);
46256 wxPyEndAllowThreads(__tstate);
46257 if (PyErr_Occurred()) SWIG_fail;
46258 }
46259 resultobj = SWIG_Py_Void();
46260 return resultobj;
46261 fail:
46262 return NULL;
46263 }
46264
46265
46266 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46267 PyObject *resultobj = 0;
46268 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46269 wxSizer *result = 0 ;
46270 void *argp1 = 0 ;
46271 int res1 = 0 ;
46272 PyObject *swig_obj[1] ;
46273
46274 if (!args) SWIG_fail;
46275 swig_obj[0] = args;
46276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46277 if (!SWIG_IsOK(res1)) {
46278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46279 }
46280 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46281 {
46282 PyThreadState* __tstate = wxPyBeginAllowThreads();
46283 result = (wxSizer *)(arg1)->GetSizer();
46284 wxPyEndAllowThreads(__tstate);
46285 if (PyErr_Occurred()) SWIG_fail;
46286 }
46287 {
46288 resultobj = wxPyMake_wxObject(result, (bool)0);
46289 }
46290 return resultobj;
46291 fail:
46292 return NULL;
46293 }
46294
46295
46296 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46297 PyObject *resultobj = 0;
46298 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46299 wxSizer *arg2 = (wxSizer *) 0 ;
46300 void *argp1 = 0 ;
46301 int res1 = 0 ;
46302 int res2 = 0 ;
46303 PyObject * obj0 = 0 ;
46304 PyObject * obj1 = 0 ;
46305 char * kwnames[] = {
46306 (char *) "self",(char *) "sizer", NULL
46307 };
46308
46309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46311 if (!SWIG_IsOK(res1)) {
46312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46313 }
46314 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46315 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46316 if (!SWIG_IsOK(res2)) {
46317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46318 }
46319 {
46320 PyThreadState* __tstate = wxPyBeginAllowThreads();
46321 (arg1)->SetSizer(arg2);
46322 wxPyEndAllowThreads(__tstate);
46323 if (PyErr_Occurred()) SWIG_fail;
46324 }
46325 resultobj = SWIG_Py_Void();
46326 return resultobj;
46327 fail:
46328 return NULL;
46329 }
46330
46331
46332 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46333 PyObject *resultobj = 0;
46334 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46335 wxSize *result = 0 ;
46336 void *argp1 = 0 ;
46337 int res1 = 0 ;
46338 PyObject *swig_obj[1] ;
46339
46340 if (!args) SWIG_fail;
46341 swig_obj[0] = args;
46342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46343 if (!SWIG_IsOK(res1)) {
46344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46345 }
46346 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46347 {
46348 PyThreadState* __tstate = wxPyBeginAllowThreads();
46349 {
46350 wxSize const &_result_ref = (arg1)->GetSpacer();
46351 result = (wxSize *) &_result_ref;
46352 }
46353 wxPyEndAllowThreads(__tstate);
46354 if (PyErr_Occurred()) SWIG_fail;
46355 }
46356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46357 return resultobj;
46358 fail:
46359 return NULL;
46360 }
46361
46362
46363 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46364 PyObject *resultobj = 0;
46365 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46366 wxSize *arg2 = 0 ;
46367 void *argp1 = 0 ;
46368 int res1 = 0 ;
46369 wxSize temp2 ;
46370 PyObject * obj0 = 0 ;
46371 PyObject * obj1 = 0 ;
46372 char * kwnames[] = {
46373 (char *) "self",(char *) "size", NULL
46374 };
46375
46376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46378 if (!SWIG_IsOK(res1)) {
46379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46380 }
46381 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46382 {
46383 arg2 = &temp2;
46384 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46385 }
46386 {
46387 PyThreadState* __tstate = wxPyBeginAllowThreads();
46388 (arg1)->SetSpacer((wxSize const &)*arg2);
46389 wxPyEndAllowThreads(__tstate);
46390 if (PyErr_Occurred()) SWIG_fail;
46391 }
46392 resultobj = SWIG_Py_Void();
46393 return resultobj;
46394 fail:
46395 return NULL;
46396 }
46397
46398
46399 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46400 PyObject *resultobj = 0;
46401 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46402 bool arg2 ;
46403 void *argp1 = 0 ;
46404 int res1 = 0 ;
46405 bool val2 ;
46406 int ecode2 = 0 ;
46407 PyObject * obj0 = 0 ;
46408 PyObject * obj1 = 0 ;
46409 char * kwnames[] = {
46410 (char *) "self",(char *) "show", NULL
46411 };
46412
46413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46415 if (!SWIG_IsOK(res1)) {
46416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46417 }
46418 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46420 if (!SWIG_IsOK(ecode2)) {
46421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46422 }
46423 arg2 = static_cast< bool >(val2);
46424 {
46425 PyThreadState* __tstate = wxPyBeginAllowThreads();
46426 (arg1)->Show(arg2);
46427 wxPyEndAllowThreads(__tstate);
46428 if (PyErr_Occurred()) SWIG_fail;
46429 }
46430 resultobj = SWIG_Py_Void();
46431 return resultobj;
46432 fail:
46433 return NULL;
46434 }
46435
46436
46437 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46438 PyObject *resultobj = 0;
46439 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46440 bool result;
46441 void *argp1 = 0 ;
46442 int res1 = 0 ;
46443 PyObject *swig_obj[1] ;
46444
46445 if (!args) SWIG_fail;
46446 swig_obj[0] = args;
46447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46448 if (!SWIG_IsOK(res1)) {
46449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46450 }
46451 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46452 {
46453 PyThreadState* __tstate = wxPyBeginAllowThreads();
46454 result = (bool)(arg1)->IsShown();
46455 wxPyEndAllowThreads(__tstate);
46456 if (PyErr_Occurred()) SWIG_fail;
46457 }
46458 {
46459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46460 }
46461 return resultobj;
46462 fail:
46463 return NULL;
46464 }
46465
46466
46467 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46468 PyObject *resultobj = 0;
46469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46470 wxPoint result;
46471 void *argp1 = 0 ;
46472 int res1 = 0 ;
46473 PyObject *swig_obj[1] ;
46474
46475 if (!args) SWIG_fail;
46476 swig_obj[0] = args;
46477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46478 if (!SWIG_IsOK(res1)) {
46479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46480 }
46481 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46482 {
46483 PyThreadState* __tstate = wxPyBeginAllowThreads();
46484 result = (arg1)->GetPosition();
46485 wxPyEndAllowThreads(__tstate);
46486 if (PyErr_Occurred()) SWIG_fail;
46487 }
46488 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46489 return resultobj;
46490 fail:
46491 return NULL;
46492 }
46493
46494
46495 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46496 PyObject *resultobj = 0;
46497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46498 PyObject *result = 0 ;
46499 void *argp1 = 0 ;
46500 int res1 = 0 ;
46501 PyObject *swig_obj[1] ;
46502
46503 if (!args) SWIG_fail;
46504 swig_obj[0] = args;
46505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46506 if (!SWIG_IsOK(res1)) {
46507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46508 }
46509 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46510 {
46511 PyThreadState* __tstate = wxPyBeginAllowThreads();
46512 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46513 wxPyEndAllowThreads(__tstate);
46514 if (PyErr_Occurred()) SWIG_fail;
46515 }
46516 resultobj = result;
46517 return resultobj;
46518 fail:
46519 return NULL;
46520 }
46521
46522
46523 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46524 PyObject *resultobj = 0;
46525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46526 PyObject *arg2 = (PyObject *) 0 ;
46527 void *argp1 = 0 ;
46528 int res1 = 0 ;
46529 PyObject * obj0 = 0 ;
46530 PyObject * obj1 = 0 ;
46531 char * kwnames[] = {
46532 (char *) "self",(char *) "userData", NULL
46533 };
46534
46535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46537 if (!SWIG_IsOK(res1)) {
46538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46539 }
46540 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46541 arg2 = obj1;
46542 {
46543 PyThreadState* __tstate = wxPyBeginAllowThreads();
46544 wxSizerItem_SetUserData(arg1,arg2);
46545 wxPyEndAllowThreads(__tstate);
46546 if (PyErr_Occurred()) SWIG_fail;
46547 }
46548 resultobj = SWIG_Py_Void();
46549 return resultobj;
46550 fail:
46551 return NULL;
46552 }
46553
46554
46555 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46556 PyObject *obj;
46557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46558 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46559 return SWIG_Py_Void();
46560 }
46561
46562 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46563 return SWIG_Python_InitShadowInstance(args);
46564 }
46565
46566 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46567 PyObject *resultobj = 0;
46568 wxSizer *arg1 = (wxSizer *) 0 ;
46569 void *argp1 = 0 ;
46570 int res1 = 0 ;
46571 PyObject *swig_obj[1] ;
46572
46573 if (!args) SWIG_fail;
46574 swig_obj[0] = args;
46575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46576 if (!SWIG_IsOK(res1)) {
46577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46578 }
46579 arg1 = reinterpret_cast< wxSizer * >(argp1);
46580 {
46581 PyThreadState* __tstate = wxPyBeginAllowThreads();
46582 delete arg1;
46583
46584 wxPyEndAllowThreads(__tstate);
46585 if (PyErr_Occurred()) SWIG_fail;
46586 }
46587 resultobj = SWIG_Py_Void();
46588 return resultobj;
46589 fail:
46590 return NULL;
46591 }
46592
46593
46594 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46595 PyObject *resultobj = 0;
46596 wxSizer *arg1 = (wxSizer *) 0 ;
46597 PyObject *arg2 = (PyObject *) 0 ;
46598 void *argp1 = 0 ;
46599 int res1 = 0 ;
46600 PyObject * obj0 = 0 ;
46601 PyObject * obj1 = 0 ;
46602 char * kwnames[] = {
46603 (char *) "self",(char *) "_self", NULL
46604 };
46605
46606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46608 if (!SWIG_IsOK(res1)) {
46609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46610 }
46611 arg1 = reinterpret_cast< wxSizer * >(argp1);
46612 arg2 = obj1;
46613 {
46614 PyThreadState* __tstate = wxPyBeginAllowThreads();
46615 wxSizer__setOORInfo(arg1,arg2);
46616 wxPyEndAllowThreads(__tstate);
46617 if (PyErr_Occurred()) SWIG_fail;
46618 }
46619 resultobj = SWIG_Py_Void();
46620 return resultobj;
46621 fail:
46622 return NULL;
46623 }
46624
46625
46626 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46627 PyObject *resultobj = 0;
46628 wxSizer *arg1 = (wxSizer *) 0 ;
46629 PyObject *arg2 = (PyObject *) 0 ;
46630 int arg3 = (int) 0 ;
46631 int arg4 = (int) 0 ;
46632 int arg5 = (int) 0 ;
46633 PyObject *arg6 = (PyObject *) NULL ;
46634 wxSizerItem *result = 0 ;
46635 void *argp1 = 0 ;
46636 int res1 = 0 ;
46637 int val3 ;
46638 int ecode3 = 0 ;
46639 int val4 ;
46640 int ecode4 = 0 ;
46641 int val5 ;
46642 int ecode5 = 0 ;
46643 PyObject * obj0 = 0 ;
46644 PyObject * obj1 = 0 ;
46645 PyObject * obj2 = 0 ;
46646 PyObject * obj3 = 0 ;
46647 PyObject * obj4 = 0 ;
46648 PyObject * obj5 = 0 ;
46649 char * kwnames[] = {
46650 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46651 };
46652
46653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46655 if (!SWIG_IsOK(res1)) {
46656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46657 }
46658 arg1 = reinterpret_cast< wxSizer * >(argp1);
46659 arg2 = obj1;
46660 if (obj2) {
46661 ecode3 = SWIG_AsVal_int(obj2, &val3);
46662 if (!SWIG_IsOK(ecode3)) {
46663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46664 }
46665 arg3 = static_cast< int >(val3);
46666 }
46667 if (obj3) {
46668 ecode4 = SWIG_AsVal_int(obj3, &val4);
46669 if (!SWIG_IsOK(ecode4)) {
46670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46671 }
46672 arg4 = static_cast< int >(val4);
46673 }
46674 if (obj4) {
46675 ecode5 = SWIG_AsVal_int(obj4, &val5);
46676 if (!SWIG_IsOK(ecode5)) {
46677 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46678 }
46679 arg5 = static_cast< int >(val5);
46680 }
46681 if (obj5) {
46682 arg6 = obj5;
46683 }
46684 {
46685 PyThreadState* __tstate = wxPyBeginAllowThreads();
46686 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46687 wxPyEndAllowThreads(__tstate);
46688 if (PyErr_Occurred()) SWIG_fail;
46689 }
46690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46691 return resultobj;
46692 fail:
46693 return NULL;
46694 }
46695
46696
46697 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46698 PyObject *resultobj = 0;
46699 wxSizer *arg1 = (wxSizer *) 0 ;
46700 int arg2 ;
46701 PyObject *arg3 = (PyObject *) 0 ;
46702 int arg4 = (int) 0 ;
46703 int arg5 = (int) 0 ;
46704 int arg6 = (int) 0 ;
46705 PyObject *arg7 = (PyObject *) NULL ;
46706 wxSizerItem *result = 0 ;
46707 void *argp1 = 0 ;
46708 int res1 = 0 ;
46709 int val2 ;
46710 int ecode2 = 0 ;
46711 int val4 ;
46712 int ecode4 = 0 ;
46713 int val5 ;
46714 int ecode5 = 0 ;
46715 int val6 ;
46716 int ecode6 = 0 ;
46717 PyObject * obj0 = 0 ;
46718 PyObject * obj1 = 0 ;
46719 PyObject * obj2 = 0 ;
46720 PyObject * obj3 = 0 ;
46721 PyObject * obj4 = 0 ;
46722 PyObject * obj5 = 0 ;
46723 PyObject * obj6 = 0 ;
46724 char * kwnames[] = {
46725 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46726 };
46727
46728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46730 if (!SWIG_IsOK(res1)) {
46731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46732 }
46733 arg1 = reinterpret_cast< wxSizer * >(argp1);
46734 ecode2 = SWIG_AsVal_int(obj1, &val2);
46735 if (!SWIG_IsOK(ecode2)) {
46736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46737 }
46738 arg2 = static_cast< int >(val2);
46739 arg3 = obj2;
46740 if (obj3) {
46741 ecode4 = SWIG_AsVal_int(obj3, &val4);
46742 if (!SWIG_IsOK(ecode4)) {
46743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46744 }
46745 arg4 = static_cast< int >(val4);
46746 }
46747 if (obj4) {
46748 ecode5 = SWIG_AsVal_int(obj4, &val5);
46749 if (!SWIG_IsOK(ecode5)) {
46750 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46751 }
46752 arg5 = static_cast< int >(val5);
46753 }
46754 if (obj5) {
46755 ecode6 = SWIG_AsVal_int(obj5, &val6);
46756 if (!SWIG_IsOK(ecode6)) {
46757 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46758 }
46759 arg6 = static_cast< int >(val6);
46760 }
46761 if (obj6) {
46762 arg7 = obj6;
46763 }
46764 {
46765 PyThreadState* __tstate = wxPyBeginAllowThreads();
46766 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46767 wxPyEndAllowThreads(__tstate);
46768 if (PyErr_Occurred()) SWIG_fail;
46769 }
46770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46771 return resultobj;
46772 fail:
46773 return NULL;
46774 }
46775
46776
46777 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46778 PyObject *resultobj = 0;
46779 wxSizer *arg1 = (wxSizer *) 0 ;
46780 PyObject *arg2 = (PyObject *) 0 ;
46781 int arg3 = (int) 0 ;
46782 int arg4 = (int) 0 ;
46783 int arg5 = (int) 0 ;
46784 PyObject *arg6 = (PyObject *) NULL ;
46785 wxSizerItem *result = 0 ;
46786 void *argp1 = 0 ;
46787 int res1 = 0 ;
46788 int val3 ;
46789 int ecode3 = 0 ;
46790 int val4 ;
46791 int ecode4 = 0 ;
46792 int val5 ;
46793 int ecode5 = 0 ;
46794 PyObject * obj0 = 0 ;
46795 PyObject * obj1 = 0 ;
46796 PyObject * obj2 = 0 ;
46797 PyObject * obj3 = 0 ;
46798 PyObject * obj4 = 0 ;
46799 PyObject * obj5 = 0 ;
46800 char * kwnames[] = {
46801 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46802 };
46803
46804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46806 if (!SWIG_IsOK(res1)) {
46807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46808 }
46809 arg1 = reinterpret_cast< wxSizer * >(argp1);
46810 arg2 = obj1;
46811 if (obj2) {
46812 ecode3 = SWIG_AsVal_int(obj2, &val3);
46813 if (!SWIG_IsOK(ecode3)) {
46814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46815 }
46816 arg3 = static_cast< int >(val3);
46817 }
46818 if (obj3) {
46819 ecode4 = SWIG_AsVal_int(obj3, &val4);
46820 if (!SWIG_IsOK(ecode4)) {
46821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46822 }
46823 arg4 = static_cast< int >(val4);
46824 }
46825 if (obj4) {
46826 ecode5 = SWIG_AsVal_int(obj4, &val5);
46827 if (!SWIG_IsOK(ecode5)) {
46828 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46829 }
46830 arg5 = static_cast< int >(val5);
46831 }
46832 if (obj5) {
46833 arg6 = obj5;
46834 }
46835 {
46836 PyThreadState* __tstate = wxPyBeginAllowThreads();
46837 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46838 wxPyEndAllowThreads(__tstate);
46839 if (PyErr_Occurred()) SWIG_fail;
46840 }
46841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46842 return resultobj;
46843 fail:
46844 return NULL;
46845 }
46846
46847
46848 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46849 PyObject *resultobj = 0;
46850 wxSizer *arg1 = (wxSizer *) 0 ;
46851 PyObject *arg2 = (PyObject *) 0 ;
46852 bool result;
46853 void *argp1 = 0 ;
46854 int res1 = 0 ;
46855 PyObject * obj0 = 0 ;
46856 PyObject * obj1 = 0 ;
46857 char * kwnames[] = {
46858 (char *) "self",(char *) "item", NULL
46859 };
46860
46861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46863 if (!SWIG_IsOK(res1)) {
46864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46865 }
46866 arg1 = reinterpret_cast< wxSizer * >(argp1);
46867 arg2 = obj1;
46868 {
46869 PyThreadState* __tstate = wxPyBeginAllowThreads();
46870 result = (bool)wxSizer_Remove(arg1,arg2);
46871 wxPyEndAllowThreads(__tstate);
46872 if (PyErr_Occurred()) SWIG_fail;
46873 }
46874 {
46875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46876 }
46877 return resultobj;
46878 fail:
46879 return NULL;
46880 }
46881
46882
46883 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46884 PyObject *resultobj = 0;
46885 wxSizer *arg1 = (wxSizer *) 0 ;
46886 PyObject *arg2 = (PyObject *) 0 ;
46887 bool result;
46888 void *argp1 = 0 ;
46889 int res1 = 0 ;
46890 PyObject * obj0 = 0 ;
46891 PyObject * obj1 = 0 ;
46892 char * kwnames[] = {
46893 (char *) "self",(char *) "item", NULL
46894 };
46895
46896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46900 }
46901 arg1 = reinterpret_cast< wxSizer * >(argp1);
46902 arg2 = obj1;
46903 {
46904 PyThreadState* __tstate = wxPyBeginAllowThreads();
46905 result = (bool)wxSizer_Detach(arg1,arg2);
46906 wxPyEndAllowThreads(__tstate);
46907 if (PyErr_Occurred()) SWIG_fail;
46908 }
46909 {
46910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46911 }
46912 return resultobj;
46913 fail:
46914 return NULL;
46915 }
46916
46917
46918 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46919 PyObject *resultobj = 0;
46920 wxSizer *arg1 = (wxSizer *) 0 ;
46921 PyObject *arg2 = (PyObject *) 0 ;
46922 wxSizerItem *result = 0 ;
46923 void *argp1 = 0 ;
46924 int res1 = 0 ;
46925 PyObject * obj0 = 0 ;
46926 PyObject * obj1 = 0 ;
46927 char * kwnames[] = {
46928 (char *) "self",(char *) "item", NULL
46929 };
46930
46931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46933 if (!SWIG_IsOK(res1)) {
46934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46935 }
46936 arg1 = reinterpret_cast< wxSizer * >(argp1);
46937 arg2 = obj1;
46938 {
46939 PyThreadState* __tstate = wxPyBeginAllowThreads();
46940 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46941 wxPyEndAllowThreads(__tstate);
46942 if (PyErr_Occurred()) SWIG_fail;
46943 }
46944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46945 return resultobj;
46946 fail:
46947 return NULL;
46948 }
46949
46950
46951 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46952 PyObject *resultobj = 0;
46953 wxSizer *arg1 = (wxSizer *) 0 ;
46954 PyObject *arg2 = (PyObject *) 0 ;
46955 wxSize *arg3 = 0 ;
46956 void *argp1 = 0 ;
46957 int res1 = 0 ;
46958 wxSize temp3 ;
46959 PyObject * obj0 = 0 ;
46960 PyObject * obj1 = 0 ;
46961 PyObject * obj2 = 0 ;
46962 char * kwnames[] = {
46963 (char *) "self",(char *) "item",(char *) "size", NULL
46964 };
46965
46966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46968 if (!SWIG_IsOK(res1)) {
46969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46970 }
46971 arg1 = reinterpret_cast< wxSizer * >(argp1);
46972 arg2 = obj1;
46973 {
46974 arg3 = &temp3;
46975 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46976 }
46977 {
46978 PyThreadState* __tstate = wxPyBeginAllowThreads();
46979 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46980 wxPyEndAllowThreads(__tstate);
46981 if (PyErr_Occurred()) SWIG_fail;
46982 }
46983 resultobj = SWIG_Py_Void();
46984 return resultobj;
46985 fail:
46986 return NULL;
46987 }
46988
46989
46990 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46991 PyObject *resultobj = 0;
46992 wxSizer *arg1 = (wxSizer *) 0 ;
46993 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46994 wxSizerItem *result = 0 ;
46995 void *argp1 = 0 ;
46996 int res1 = 0 ;
46997 int res2 = 0 ;
46998 PyObject * obj0 = 0 ;
46999 PyObject * obj1 = 0 ;
47000 char * kwnames[] = {
47001 (char *) "self",(char *) "item", NULL
47002 };
47003
47004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47006 if (!SWIG_IsOK(res1)) {
47007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47008 }
47009 arg1 = reinterpret_cast< wxSizer * >(argp1);
47010 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47011 if (!SWIG_IsOK(res2)) {
47012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47013 }
47014 {
47015 PyThreadState* __tstate = wxPyBeginAllowThreads();
47016 result = (wxSizerItem *)(arg1)->Add(arg2);
47017 wxPyEndAllowThreads(__tstate);
47018 if (PyErr_Occurred()) SWIG_fail;
47019 }
47020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47021 return resultobj;
47022 fail:
47023 return NULL;
47024 }
47025
47026
47027 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47028 PyObject *resultobj = 0;
47029 wxSizer *arg1 = (wxSizer *) 0 ;
47030 size_t arg2 ;
47031 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47032 wxSizerItem *result = 0 ;
47033 void *argp1 = 0 ;
47034 int res1 = 0 ;
47035 size_t val2 ;
47036 int ecode2 = 0 ;
47037 int res3 = 0 ;
47038 PyObject * obj0 = 0 ;
47039 PyObject * obj1 = 0 ;
47040 PyObject * obj2 = 0 ;
47041 char * kwnames[] = {
47042 (char *) "self",(char *) "index",(char *) "item", NULL
47043 };
47044
47045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47047 if (!SWIG_IsOK(res1)) {
47048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47049 }
47050 arg1 = reinterpret_cast< wxSizer * >(argp1);
47051 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47052 if (!SWIG_IsOK(ecode2)) {
47053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47054 }
47055 arg2 = static_cast< size_t >(val2);
47056 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47057 if (!SWIG_IsOK(res3)) {
47058 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47059 }
47060 {
47061 PyThreadState* __tstate = wxPyBeginAllowThreads();
47062 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47063 wxPyEndAllowThreads(__tstate);
47064 if (PyErr_Occurred()) SWIG_fail;
47065 }
47066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47067 return resultobj;
47068 fail:
47069 return NULL;
47070 }
47071
47072
47073 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47074 PyObject *resultobj = 0;
47075 wxSizer *arg1 = (wxSizer *) 0 ;
47076 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47077 wxSizerItem *result = 0 ;
47078 void *argp1 = 0 ;
47079 int res1 = 0 ;
47080 int res2 = 0 ;
47081 PyObject * obj0 = 0 ;
47082 PyObject * obj1 = 0 ;
47083 char * kwnames[] = {
47084 (char *) "self",(char *) "item", NULL
47085 };
47086
47087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47089 if (!SWIG_IsOK(res1)) {
47090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47091 }
47092 arg1 = reinterpret_cast< wxSizer * >(argp1);
47093 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47094 if (!SWIG_IsOK(res2)) {
47095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47096 }
47097 {
47098 PyThreadState* __tstate = wxPyBeginAllowThreads();
47099 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47100 wxPyEndAllowThreads(__tstate);
47101 if (PyErr_Occurred()) SWIG_fail;
47102 }
47103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47104 return resultobj;
47105 fail:
47106 return NULL;
47107 }
47108
47109
47110 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47111 PyObject *resultobj = 0;
47112 wxSizer *arg1 = (wxSizer *) 0 ;
47113 int arg2 ;
47114 int arg3 ;
47115 int arg4 ;
47116 int arg5 ;
47117 void *argp1 = 0 ;
47118 int res1 = 0 ;
47119 int val2 ;
47120 int ecode2 = 0 ;
47121 int val3 ;
47122 int ecode3 = 0 ;
47123 int val4 ;
47124 int ecode4 = 0 ;
47125 int val5 ;
47126 int ecode5 = 0 ;
47127 PyObject * obj0 = 0 ;
47128 PyObject * obj1 = 0 ;
47129 PyObject * obj2 = 0 ;
47130 PyObject * obj3 = 0 ;
47131 PyObject * obj4 = 0 ;
47132 char * kwnames[] = {
47133 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47134 };
47135
47136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47138 if (!SWIG_IsOK(res1)) {
47139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47140 }
47141 arg1 = reinterpret_cast< wxSizer * >(argp1);
47142 ecode2 = SWIG_AsVal_int(obj1, &val2);
47143 if (!SWIG_IsOK(ecode2)) {
47144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47145 }
47146 arg2 = static_cast< int >(val2);
47147 ecode3 = SWIG_AsVal_int(obj2, &val3);
47148 if (!SWIG_IsOK(ecode3)) {
47149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47150 }
47151 arg3 = static_cast< int >(val3);
47152 ecode4 = SWIG_AsVal_int(obj3, &val4);
47153 if (!SWIG_IsOK(ecode4)) {
47154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47155 }
47156 arg4 = static_cast< int >(val4);
47157 ecode5 = SWIG_AsVal_int(obj4, &val5);
47158 if (!SWIG_IsOK(ecode5)) {
47159 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47160 }
47161 arg5 = static_cast< int >(val5);
47162 {
47163 PyThreadState* __tstate = wxPyBeginAllowThreads();
47164 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47165 wxPyEndAllowThreads(__tstate);
47166 if (PyErr_Occurred()) SWIG_fail;
47167 }
47168 resultobj = SWIG_Py_Void();
47169 return resultobj;
47170 fail:
47171 return NULL;
47172 }
47173
47174
47175 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 wxSizer *arg1 = (wxSizer *) 0 ;
47178 wxSize *arg2 = 0 ;
47179 void *argp1 = 0 ;
47180 int res1 = 0 ;
47181 wxSize temp2 ;
47182 PyObject * obj0 = 0 ;
47183 PyObject * obj1 = 0 ;
47184 char * kwnames[] = {
47185 (char *) "self",(char *) "size", NULL
47186 };
47187
47188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47190 if (!SWIG_IsOK(res1)) {
47191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47192 }
47193 arg1 = reinterpret_cast< wxSizer * >(argp1);
47194 {
47195 arg2 = &temp2;
47196 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47197 }
47198 {
47199 PyThreadState* __tstate = wxPyBeginAllowThreads();
47200 (arg1)->SetMinSize((wxSize const &)*arg2);
47201 wxPyEndAllowThreads(__tstate);
47202 if (PyErr_Occurred()) SWIG_fail;
47203 }
47204 resultobj = SWIG_Py_Void();
47205 return resultobj;
47206 fail:
47207 return NULL;
47208 }
47209
47210
47211 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47212 PyObject *resultobj = 0;
47213 wxSizer *arg1 = (wxSizer *) 0 ;
47214 wxSize result;
47215 void *argp1 = 0 ;
47216 int res1 = 0 ;
47217 PyObject *swig_obj[1] ;
47218
47219 if (!args) SWIG_fail;
47220 swig_obj[0] = args;
47221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47222 if (!SWIG_IsOK(res1)) {
47223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47224 }
47225 arg1 = reinterpret_cast< wxSizer * >(argp1);
47226 {
47227 PyThreadState* __tstate = wxPyBeginAllowThreads();
47228 result = (arg1)->GetSize();
47229 wxPyEndAllowThreads(__tstate);
47230 if (PyErr_Occurred()) SWIG_fail;
47231 }
47232 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47233 return resultobj;
47234 fail:
47235 return NULL;
47236 }
47237
47238
47239 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47240 PyObject *resultobj = 0;
47241 wxSizer *arg1 = (wxSizer *) 0 ;
47242 wxPoint result;
47243 void *argp1 = 0 ;
47244 int res1 = 0 ;
47245 PyObject *swig_obj[1] ;
47246
47247 if (!args) SWIG_fail;
47248 swig_obj[0] = args;
47249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47250 if (!SWIG_IsOK(res1)) {
47251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47252 }
47253 arg1 = reinterpret_cast< wxSizer * >(argp1);
47254 {
47255 PyThreadState* __tstate = wxPyBeginAllowThreads();
47256 result = (arg1)->GetPosition();
47257 wxPyEndAllowThreads(__tstate);
47258 if (PyErr_Occurred()) SWIG_fail;
47259 }
47260 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47261 return resultobj;
47262 fail:
47263 return NULL;
47264 }
47265
47266
47267 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47268 PyObject *resultobj = 0;
47269 wxSizer *arg1 = (wxSizer *) 0 ;
47270 wxSize result;
47271 void *argp1 = 0 ;
47272 int res1 = 0 ;
47273 PyObject *swig_obj[1] ;
47274
47275 if (!args) SWIG_fail;
47276 swig_obj[0] = args;
47277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47278 if (!SWIG_IsOK(res1)) {
47279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47280 }
47281 arg1 = reinterpret_cast< wxSizer * >(argp1);
47282 {
47283 PyThreadState* __tstate = wxPyBeginAllowThreads();
47284 result = (arg1)->GetMinSize();
47285 wxPyEndAllowThreads(__tstate);
47286 if (PyErr_Occurred()) SWIG_fail;
47287 }
47288 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47289 return resultobj;
47290 fail:
47291 return NULL;
47292 }
47293
47294
47295 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47296 PyObject *resultobj = 0;
47297 wxSizer *arg1 = (wxSizer *) 0 ;
47298 void *argp1 = 0 ;
47299 int res1 = 0 ;
47300 PyObject *swig_obj[1] ;
47301
47302 if (!args) SWIG_fail;
47303 swig_obj[0] = args;
47304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47305 if (!SWIG_IsOK(res1)) {
47306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47307 }
47308 arg1 = reinterpret_cast< wxSizer * >(argp1);
47309 {
47310 PyThreadState* __tstate = wxPyBeginAllowThreads();
47311 (arg1)->RecalcSizes();
47312 wxPyEndAllowThreads(__tstate);
47313 if (PyErr_Occurred()) SWIG_fail;
47314 }
47315 resultobj = SWIG_Py_Void();
47316 return resultobj;
47317 fail:
47318 return NULL;
47319 }
47320
47321
47322 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47323 PyObject *resultobj = 0;
47324 wxSizer *arg1 = (wxSizer *) 0 ;
47325 wxSize result;
47326 void *argp1 = 0 ;
47327 int res1 = 0 ;
47328 PyObject *swig_obj[1] ;
47329
47330 if (!args) SWIG_fail;
47331 swig_obj[0] = args;
47332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47333 if (!SWIG_IsOK(res1)) {
47334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47335 }
47336 arg1 = reinterpret_cast< wxSizer * >(argp1);
47337 {
47338 PyThreadState* __tstate = wxPyBeginAllowThreads();
47339 result = (arg1)->CalcMin();
47340 wxPyEndAllowThreads(__tstate);
47341 if (PyErr_Occurred()) SWIG_fail;
47342 }
47343 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47344 return resultobj;
47345 fail:
47346 return NULL;
47347 }
47348
47349
47350 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47351 PyObject *resultobj = 0;
47352 wxSizer *arg1 = (wxSizer *) 0 ;
47353 void *argp1 = 0 ;
47354 int res1 = 0 ;
47355 PyObject *swig_obj[1] ;
47356
47357 if (!args) SWIG_fail;
47358 swig_obj[0] = args;
47359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47362 }
47363 arg1 = reinterpret_cast< wxSizer * >(argp1);
47364 {
47365 PyThreadState* __tstate = wxPyBeginAllowThreads();
47366 (arg1)->Layout();
47367 wxPyEndAllowThreads(__tstate);
47368 if (PyErr_Occurred()) SWIG_fail;
47369 }
47370 resultobj = SWIG_Py_Void();
47371 return resultobj;
47372 fail:
47373 return NULL;
47374 }
47375
47376
47377 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47378 PyObject *resultobj = 0;
47379 wxSizer *arg1 = (wxSizer *) 0 ;
47380 wxWindow *arg2 = (wxWindow *) 0 ;
47381 wxSize result;
47382 void *argp1 = 0 ;
47383 int res1 = 0 ;
47384 void *argp2 = 0 ;
47385 int res2 = 0 ;
47386 PyObject * obj0 = 0 ;
47387 PyObject * obj1 = 0 ;
47388 char * kwnames[] = {
47389 (char *) "self",(char *) "window", NULL
47390 };
47391
47392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47394 if (!SWIG_IsOK(res1)) {
47395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47396 }
47397 arg1 = reinterpret_cast< wxSizer * >(argp1);
47398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47399 if (!SWIG_IsOK(res2)) {
47400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47401 }
47402 arg2 = reinterpret_cast< wxWindow * >(argp2);
47403 {
47404 PyThreadState* __tstate = wxPyBeginAllowThreads();
47405 result = (arg1)->Fit(arg2);
47406 wxPyEndAllowThreads(__tstate);
47407 if (PyErr_Occurred()) SWIG_fail;
47408 }
47409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47410 return resultobj;
47411 fail:
47412 return NULL;
47413 }
47414
47415
47416 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47417 PyObject *resultobj = 0;
47418 wxSizer *arg1 = (wxSizer *) 0 ;
47419 wxWindow *arg2 = (wxWindow *) 0 ;
47420 void *argp1 = 0 ;
47421 int res1 = 0 ;
47422 void *argp2 = 0 ;
47423 int res2 = 0 ;
47424 PyObject * obj0 = 0 ;
47425 PyObject * obj1 = 0 ;
47426 char * kwnames[] = {
47427 (char *) "self",(char *) "window", NULL
47428 };
47429
47430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47432 if (!SWIG_IsOK(res1)) {
47433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47434 }
47435 arg1 = reinterpret_cast< wxSizer * >(argp1);
47436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47437 if (!SWIG_IsOK(res2)) {
47438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47439 }
47440 arg2 = reinterpret_cast< wxWindow * >(argp2);
47441 {
47442 PyThreadState* __tstate = wxPyBeginAllowThreads();
47443 (arg1)->FitInside(arg2);
47444 wxPyEndAllowThreads(__tstate);
47445 if (PyErr_Occurred()) SWIG_fail;
47446 }
47447 resultobj = SWIG_Py_Void();
47448 return resultobj;
47449 fail:
47450 return NULL;
47451 }
47452
47453
47454 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47455 PyObject *resultobj = 0;
47456 wxSizer *arg1 = (wxSizer *) 0 ;
47457 wxWindow *arg2 = (wxWindow *) 0 ;
47458 void *argp1 = 0 ;
47459 int res1 = 0 ;
47460 void *argp2 = 0 ;
47461 int res2 = 0 ;
47462 PyObject * obj0 = 0 ;
47463 PyObject * obj1 = 0 ;
47464 char * kwnames[] = {
47465 (char *) "self",(char *) "window", NULL
47466 };
47467
47468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47470 if (!SWIG_IsOK(res1)) {
47471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47472 }
47473 arg1 = reinterpret_cast< wxSizer * >(argp1);
47474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47475 if (!SWIG_IsOK(res2)) {
47476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47477 }
47478 arg2 = reinterpret_cast< wxWindow * >(argp2);
47479 {
47480 PyThreadState* __tstate = wxPyBeginAllowThreads();
47481 (arg1)->SetSizeHints(arg2);
47482 wxPyEndAllowThreads(__tstate);
47483 if (PyErr_Occurred()) SWIG_fail;
47484 }
47485 resultobj = SWIG_Py_Void();
47486 return resultobj;
47487 fail:
47488 return NULL;
47489 }
47490
47491
47492 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47493 PyObject *resultobj = 0;
47494 wxSizer *arg1 = (wxSizer *) 0 ;
47495 wxWindow *arg2 = (wxWindow *) 0 ;
47496 void *argp1 = 0 ;
47497 int res1 = 0 ;
47498 void *argp2 = 0 ;
47499 int res2 = 0 ;
47500 PyObject * obj0 = 0 ;
47501 PyObject * obj1 = 0 ;
47502 char * kwnames[] = {
47503 (char *) "self",(char *) "window", NULL
47504 };
47505
47506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47508 if (!SWIG_IsOK(res1)) {
47509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47510 }
47511 arg1 = reinterpret_cast< wxSizer * >(argp1);
47512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47513 if (!SWIG_IsOK(res2)) {
47514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47515 }
47516 arg2 = reinterpret_cast< wxWindow * >(argp2);
47517 {
47518 PyThreadState* __tstate = wxPyBeginAllowThreads();
47519 (arg1)->SetVirtualSizeHints(arg2);
47520 wxPyEndAllowThreads(__tstate);
47521 if (PyErr_Occurred()) SWIG_fail;
47522 }
47523 resultobj = SWIG_Py_Void();
47524 return resultobj;
47525 fail:
47526 return NULL;
47527 }
47528
47529
47530 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47531 PyObject *resultobj = 0;
47532 wxSizer *arg1 = (wxSizer *) 0 ;
47533 bool arg2 = (bool) false ;
47534 void *argp1 = 0 ;
47535 int res1 = 0 ;
47536 bool val2 ;
47537 int ecode2 = 0 ;
47538 PyObject * obj0 = 0 ;
47539 PyObject * obj1 = 0 ;
47540 char * kwnames[] = {
47541 (char *) "self",(char *) "deleteWindows", NULL
47542 };
47543
47544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47546 if (!SWIG_IsOK(res1)) {
47547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47548 }
47549 arg1 = reinterpret_cast< wxSizer * >(argp1);
47550 if (obj1) {
47551 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47552 if (!SWIG_IsOK(ecode2)) {
47553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47554 }
47555 arg2 = static_cast< bool >(val2);
47556 }
47557 {
47558 PyThreadState* __tstate = wxPyBeginAllowThreads();
47559 (arg1)->Clear(arg2);
47560 wxPyEndAllowThreads(__tstate);
47561 if (PyErr_Occurred()) SWIG_fail;
47562 }
47563 resultobj = SWIG_Py_Void();
47564 return resultobj;
47565 fail:
47566 return NULL;
47567 }
47568
47569
47570 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47571 PyObject *resultobj = 0;
47572 wxSizer *arg1 = (wxSizer *) 0 ;
47573 void *argp1 = 0 ;
47574 int res1 = 0 ;
47575 PyObject *swig_obj[1] ;
47576
47577 if (!args) SWIG_fail;
47578 swig_obj[0] = args;
47579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47580 if (!SWIG_IsOK(res1)) {
47581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47582 }
47583 arg1 = reinterpret_cast< wxSizer * >(argp1);
47584 {
47585 PyThreadState* __tstate = wxPyBeginAllowThreads();
47586 (arg1)->DeleteWindows();
47587 wxPyEndAllowThreads(__tstate);
47588 if (PyErr_Occurred()) SWIG_fail;
47589 }
47590 resultobj = SWIG_Py_Void();
47591 return resultobj;
47592 fail:
47593 return NULL;
47594 }
47595
47596
47597 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47598 PyObject *resultobj = 0;
47599 wxSizer *arg1 = (wxSizer *) 0 ;
47600 PyObject *result = 0 ;
47601 void *argp1 = 0 ;
47602 int res1 = 0 ;
47603 PyObject *swig_obj[1] ;
47604
47605 if (!args) SWIG_fail;
47606 swig_obj[0] = args;
47607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47608 if (!SWIG_IsOK(res1)) {
47609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47610 }
47611 arg1 = reinterpret_cast< wxSizer * >(argp1);
47612 {
47613 PyThreadState* __tstate = wxPyBeginAllowThreads();
47614 result = (PyObject *)wxSizer_GetChildren(arg1);
47615 wxPyEndAllowThreads(__tstate);
47616 if (PyErr_Occurred()) SWIG_fail;
47617 }
47618 resultobj = result;
47619 return resultobj;
47620 fail:
47621 return NULL;
47622 }
47623
47624
47625 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47626 PyObject *resultobj = 0;
47627 wxSizer *arg1 = (wxSizer *) 0 ;
47628 PyObject *arg2 = (PyObject *) 0 ;
47629 bool arg3 = (bool) true ;
47630 bool arg4 = (bool) false ;
47631 bool result;
47632 void *argp1 = 0 ;
47633 int res1 = 0 ;
47634 bool val3 ;
47635 int ecode3 = 0 ;
47636 bool val4 ;
47637 int ecode4 = 0 ;
47638 PyObject * obj0 = 0 ;
47639 PyObject * obj1 = 0 ;
47640 PyObject * obj2 = 0 ;
47641 PyObject * obj3 = 0 ;
47642 char * kwnames[] = {
47643 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47644 };
47645
47646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47648 if (!SWIG_IsOK(res1)) {
47649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47650 }
47651 arg1 = reinterpret_cast< wxSizer * >(argp1);
47652 arg2 = obj1;
47653 if (obj2) {
47654 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47655 if (!SWIG_IsOK(ecode3)) {
47656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47657 }
47658 arg3 = static_cast< bool >(val3);
47659 }
47660 if (obj3) {
47661 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47662 if (!SWIG_IsOK(ecode4)) {
47663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47664 }
47665 arg4 = static_cast< bool >(val4);
47666 }
47667 {
47668 PyThreadState* __tstate = wxPyBeginAllowThreads();
47669 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47670 wxPyEndAllowThreads(__tstate);
47671 if (PyErr_Occurred()) SWIG_fail;
47672 }
47673 {
47674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47675 }
47676 return resultobj;
47677 fail:
47678 return NULL;
47679 }
47680
47681
47682 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47683 PyObject *resultobj = 0;
47684 wxSizer *arg1 = (wxSizer *) 0 ;
47685 PyObject *arg2 = (PyObject *) 0 ;
47686 bool result;
47687 void *argp1 = 0 ;
47688 int res1 = 0 ;
47689 PyObject * obj0 = 0 ;
47690 PyObject * obj1 = 0 ;
47691 char * kwnames[] = {
47692 (char *) "self",(char *) "item", NULL
47693 };
47694
47695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47697 if (!SWIG_IsOK(res1)) {
47698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47699 }
47700 arg1 = reinterpret_cast< wxSizer * >(argp1);
47701 arg2 = obj1;
47702 {
47703 PyThreadState* __tstate = wxPyBeginAllowThreads();
47704 result = (bool)wxSizer_IsShown(arg1,arg2);
47705 wxPyEndAllowThreads(__tstate);
47706 if (PyErr_Occurred()) SWIG_fail;
47707 }
47708 {
47709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47710 }
47711 return resultobj;
47712 fail:
47713 return NULL;
47714 }
47715
47716
47717 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47718 PyObject *resultobj = 0;
47719 wxSizer *arg1 = (wxSizer *) 0 ;
47720 bool arg2 ;
47721 void *argp1 = 0 ;
47722 int res1 = 0 ;
47723 bool val2 ;
47724 int ecode2 = 0 ;
47725 PyObject * obj0 = 0 ;
47726 PyObject * obj1 = 0 ;
47727 char * kwnames[] = {
47728 (char *) "self",(char *) "show", NULL
47729 };
47730
47731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47733 if (!SWIG_IsOK(res1)) {
47734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47735 }
47736 arg1 = reinterpret_cast< wxSizer * >(argp1);
47737 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47738 if (!SWIG_IsOK(ecode2)) {
47739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47740 }
47741 arg2 = static_cast< bool >(val2);
47742 {
47743 PyThreadState* __tstate = wxPyBeginAllowThreads();
47744 (arg1)->ShowItems(arg2);
47745 wxPyEndAllowThreads(__tstate);
47746 if (PyErr_Occurred()) SWIG_fail;
47747 }
47748 resultobj = SWIG_Py_Void();
47749 return resultobj;
47750 fail:
47751 return NULL;
47752 }
47753
47754
47755 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47756 PyObject *obj;
47757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47758 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47759 return SWIG_Py_Void();
47760 }
47761
47762 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47763 PyObject *resultobj = 0;
47764 wxPySizer *result = 0 ;
47765
47766 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47767 {
47768 PyThreadState* __tstate = wxPyBeginAllowThreads();
47769 result = (wxPySizer *)new wxPySizer();
47770 wxPyEndAllowThreads(__tstate);
47771 if (PyErr_Occurred()) SWIG_fail;
47772 }
47773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47774 return resultobj;
47775 fail:
47776 return NULL;
47777 }
47778
47779
47780 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47781 PyObject *resultobj = 0;
47782 wxPySizer *arg1 = (wxPySizer *) 0 ;
47783 PyObject *arg2 = (PyObject *) 0 ;
47784 PyObject *arg3 = (PyObject *) 0 ;
47785 void *argp1 = 0 ;
47786 int res1 = 0 ;
47787 PyObject * obj0 = 0 ;
47788 PyObject * obj1 = 0 ;
47789 PyObject * obj2 = 0 ;
47790 char * kwnames[] = {
47791 (char *) "self",(char *) "self",(char *) "_class", NULL
47792 };
47793
47794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47796 if (!SWIG_IsOK(res1)) {
47797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47798 }
47799 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47800 arg2 = obj1;
47801 arg3 = obj2;
47802 {
47803 PyThreadState* __tstate = wxPyBeginAllowThreads();
47804 (arg1)->_setCallbackInfo(arg2,arg3);
47805 wxPyEndAllowThreads(__tstate);
47806 if (PyErr_Occurred()) SWIG_fail;
47807 }
47808 resultobj = SWIG_Py_Void();
47809 return resultobj;
47810 fail:
47811 return NULL;
47812 }
47813
47814
47815 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47816 PyObject *obj;
47817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47818 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47819 return SWIG_Py_Void();
47820 }
47821
47822 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47823 return SWIG_Python_InitShadowInstance(args);
47824 }
47825
47826 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47827 PyObject *resultobj = 0;
47828 int arg1 = (int) wxHORIZONTAL ;
47829 wxBoxSizer *result = 0 ;
47830 int val1 ;
47831 int ecode1 = 0 ;
47832 PyObject * obj0 = 0 ;
47833 char * kwnames[] = {
47834 (char *) "orient", NULL
47835 };
47836
47837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47838 if (obj0) {
47839 ecode1 = SWIG_AsVal_int(obj0, &val1);
47840 if (!SWIG_IsOK(ecode1)) {
47841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47842 }
47843 arg1 = static_cast< int >(val1);
47844 }
47845 {
47846 PyThreadState* __tstate = wxPyBeginAllowThreads();
47847 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47848 wxPyEndAllowThreads(__tstate);
47849 if (PyErr_Occurred()) SWIG_fail;
47850 }
47851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47852 return resultobj;
47853 fail:
47854 return NULL;
47855 }
47856
47857
47858 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47859 PyObject *resultobj = 0;
47860 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47861 int result;
47862 void *argp1 = 0 ;
47863 int res1 = 0 ;
47864 PyObject *swig_obj[1] ;
47865
47866 if (!args) SWIG_fail;
47867 swig_obj[0] = args;
47868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47869 if (!SWIG_IsOK(res1)) {
47870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47871 }
47872 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47873 {
47874 PyThreadState* __tstate = wxPyBeginAllowThreads();
47875 result = (int)(arg1)->GetOrientation();
47876 wxPyEndAllowThreads(__tstate);
47877 if (PyErr_Occurred()) SWIG_fail;
47878 }
47879 resultobj = SWIG_From_int(static_cast< int >(result));
47880 return resultobj;
47881 fail:
47882 return NULL;
47883 }
47884
47885
47886 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47887 PyObject *resultobj = 0;
47888 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47889 int arg2 ;
47890 void *argp1 = 0 ;
47891 int res1 = 0 ;
47892 int val2 ;
47893 int ecode2 = 0 ;
47894 PyObject * obj0 = 0 ;
47895 PyObject * obj1 = 0 ;
47896 char * kwnames[] = {
47897 (char *) "self",(char *) "orient", NULL
47898 };
47899
47900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47902 if (!SWIG_IsOK(res1)) {
47903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47904 }
47905 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47906 ecode2 = SWIG_AsVal_int(obj1, &val2);
47907 if (!SWIG_IsOK(ecode2)) {
47908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47909 }
47910 arg2 = static_cast< int >(val2);
47911 {
47912 PyThreadState* __tstate = wxPyBeginAllowThreads();
47913 (arg1)->SetOrientation(arg2);
47914 wxPyEndAllowThreads(__tstate);
47915 if (PyErr_Occurred()) SWIG_fail;
47916 }
47917 resultobj = SWIG_Py_Void();
47918 return resultobj;
47919 fail:
47920 return NULL;
47921 }
47922
47923
47924 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47925 PyObject *obj;
47926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47927 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47928 return SWIG_Py_Void();
47929 }
47930
47931 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47932 return SWIG_Python_InitShadowInstance(args);
47933 }
47934
47935 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47936 PyObject *resultobj = 0;
47937 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47938 int arg2 = (int) wxHORIZONTAL ;
47939 wxStaticBoxSizer *result = 0 ;
47940 void *argp1 = 0 ;
47941 int res1 = 0 ;
47942 int val2 ;
47943 int ecode2 = 0 ;
47944 PyObject * obj0 = 0 ;
47945 PyObject * obj1 = 0 ;
47946 char * kwnames[] = {
47947 (char *) "box",(char *) "orient", NULL
47948 };
47949
47950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47952 if (!SWIG_IsOK(res1)) {
47953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47954 }
47955 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47956 if (obj1) {
47957 ecode2 = SWIG_AsVal_int(obj1, &val2);
47958 if (!SWIG_IsOK(ecode2)) {
47959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47960 }
47961 arg2 = static_cast< int >(val2);
47962 }
47963 {
47964 PyThreadState* __tstate = wxPyBeginAllowThreads();
47965 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47966 wxPyEndAllowThreads(__tstate);
47967 if (PyErr_Occurred()) SWIG_fail;
47968 }
47969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47970 return resultobj;
47971 fail:
47972 return NULL;
47973 }
47974
47975
47976 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47977 PyObject *resultobj = 0;
47978 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47979 wxStaticBox *result = 0 ;
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_wxStaticBoxSizer, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47989 }
47990 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47991 {
47992 PyThreadState* __tstate = wxPyBeginAllowThreads();
47993 result = (wxStaticBox *)(arg1)->GetStaticBox();
47994 wxPyEndAllowThreads(__tstate);
47995 if (PyErr_Occurred()) SWIG_fail;
47996 }
47997 {
47998 resultobj = wxPyMake_wxObject(result, (bool)0);
47999 }
48000 return resultobj;
48001 fail:
48002 return NULL;
48003 }
48004
48005
48006 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48007 PyObject *obj;
48008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48009 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48010 return SWIG_Py_Void();
48011 }
48012
48013 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48014 return SWIG_Python_InitShadowInstance(args);
48015 }
48016
48017 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48018 PyObject *resultobj = 0;
48019 int arg1 = (int) 1 ;
48020 int arg2 = (int) 0 ;
48021 int arg3 = (int) 0 ;
48022 int arg4 = (int) 0 ;
48023 wxGridSizer *result = 0 ;
48024 int val1 ;
48025 int ecode1 = 0 ;
48026 int val2 ;
48027 int ecode2 = 0 ;
48028 int val3 ;
48029 int ecode3 = 0 ;
48030 int val4 ;
48031 int ecode4 = 0 ;
48032 PyObject * obj0 = 0 ;
48033 PyObject * obj1 = 0 ;
48034 PyObject * obj2 = 0 ;
48035 PyObject * obj3 = 0 ;
48036 char * kwnames[] = {
48037 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48038 };
48039
48040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48041 if (obj0) {
48042 ecode1 = SWIG_AsVal_int(obj0, &val1);
48043 if (!SWIG_IsOK(ecode1)) {
48044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48045 }
48046 arg1 = static_cast< int >(val1);
48047 }
48048 if (obj1) {
48049 ecode2 = SWIG_AsVal_int(obj1, &val2);
48050 if (!SWIG_IsOK(ecode2)) {
48051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48052 }
48053 arg2 = static_cast< int >(val2);
48054 }
48055 if (obj2) {
48056 ecode3 = SWIG_AsVal_int(obj2, &val3);
48057 if (!SWIG_IsOK(ecode3)) {
48058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48059 }
48060 arg3 = static_cast< int >(val3);
48061 }
48062 if (obj3) {
48063 ecode4 = SWIG_AsVal_int(obj3, &val4);
48064 if (!SWIG_IsOK(ecode4)) {
48065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48066 }
48067 arg4 = static_cast< int >(val4);
48068 }
48069 {
48070 PyThreadState* __tstate = wxPyBeginAllowThreads();
48071 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48072 wxPyEndAllowThreads(__tstate);
48073 if (PyErr_Occurred()) SWIG_fail;
48074 }
48075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48076 return resultobj;
48077 fail:
48078 return NULL;
48079 }
48080
48081
48082 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48083 PyObject *resultobj = 0;
48084 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48085 int arg2 ;
48086 void *argp1 = 0 ;
48087 int res1 = 0 ;
48088 int val2 ;
48089 int ecode2 = 0 ;
48090 PyObject * obj0 = 0 ;
48091 PyObject * obj1 = 0 ;
48092 char * kwnames[] = {
48093 (char *) "self",(char *) "cols", NULL
48094 };
48095
48096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48098 if (!SWIG_IsOK(res1)) {
48099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48100 }
48101 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48102 ecode2 = SWIG_AsVal_int(obj1, &val2);
48103 if (!SWIG_IsOK(ecode2)) {
48104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48105 }
48106 arg2 = static_cast< int >(val2);
48107 {
48108 PyThreadState* __tstate = wxPyBeginAllowThreads();
48109 (arg1)->SetCols(arg2);
48110 wxPyEndAllowThreads(__tstate);
48111 if (PyErr_Occurred()) SWIG_fail;
48112 }
48113 resultobj = SWIG_Py_Void();
48114 return resultobj;
48115 fail:
48116 return NULL;
48117 }
48118
48119
48120 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48121 PyObject *resultobj = 0;
48122 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48123 int arg2 ;
48124 void *argp1 = 0 ;
48125 int res1 = 0 ;
48126 int val2 ;
48127 int ecode2 = 0 ;
48128 PyObject * obj0 = 0 ;
48129 PyObject * obj1 = 0 ;
48130 char * kwnames[] = {
48131 (char *) "self",(char *) "rows", NULL
48132 };
48133
48134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48136 if (!SWIG_IsOK(res1)) {
48137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48138 }
48139 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48140 ecode2 = SWIG_AsVal_int(obj1, &val2);
48141 if (!SWIG_IsOK(ecode2)) {
48142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48143 }
48144 arg2 = static_cast< int >(val2);
48145 {
48146 PyThreadState* __tstate = wxPyBeginAllowThreads();
48147 (arg1)->SetRows(arg2);
48148 wxPyEndAllowThreads(__tstate);
48149 if (PyErr_Occurred()) SWIG_fail;
48150 }
48151 resultobj = SWIG_Py_Void();
48152 return resultobj;
48153 fail:
48154 return NULL;
48155 }
48156
48157
48158 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48159 PyObject *resultobj = 0;
48160 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48161 int arg2 ;
48162 void *argp1 = 0 ;
48163 int res1 = 0 ;
48164 int val2 ;
48165 int ecode2 = 0 ;
48166 PyObject * obj0 = 0 ;
48167 PyObject * obj1 = 0 ;
48168 char * kwnames[] = {
48169 (char *) "self",(char *) "gap", NULL
48170 };
48171
48172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48174 if (!SWIG_IsOK(res1)) {
48175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48176 }
48177 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48178 ecode2 = SWIG_AsVal_int(obj1, &val2);
48179 if (!SWIG_IsOK(ecode2)) {
48180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48181 }
48182 arg2 = static_cast< int >(val2);
48183 {
48184 PyThreadState* __tstate = wxPyBeginAllowThreads();
48185 (arg1)->SetVGap(arg2);
48186 wxPyEndAllowThreads(__tstate);
48187 if (PyErr_Occurred()) SWIG_fail;
48188 }
48189 resultobj = SWIG_Py_Void();
48190 return resultobj;
48191 fail:
48192 return NULL;
48193 }
48194
48195
48196 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48197 PyObject *resultobj = 0;
48198 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48199 int arg2 ;
48200 void *argp1 = 0 ;
48201 int res1 = 0 ;
48202 int val2 ;
48203 int ecode2 = 0 ;
48204 PyObject * obj0 = 0 ;
48205 PyObject * obj1 = 0 ;
48206 char * kwnames[] = {
48207 (char *) "self",(char *) "gap", NULL
48208 };
48209
48210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48212 if (!SWIG_IsOK(res1)) {
48213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48214 }
48215 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48216 ecode2 = SWIG_AsVal_int(obj1, &val2);
48217 if (!SWIG_IsOK(ecode2)) {
48218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48219 }
48220 arg2 = static_cast< int >(val2);
48221 {
48222 PyThreadState* __tstate = wxPyBeginAllowThreads();
48223 (arg1)->SetHGap(arg2);
48224 wxPyEndAllowThreads(__tstate);
48225 if (PyErr_Occurred()) SWIG_fail;
48226 }
48227 resultobj = SWIG_Py_Void();
48228 return resultobj;
48229 fail:
48230 return NULL;
48231 }
48232
48233
48234 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48235 PyObject *resultobj = 0;
48236 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48237 int result;
48238 void *argp1 = 0 ;
48239 int res1 = 0 ;
48240 PyObject *swig_obj[1] ;
48241
48242 if (!args) SWIG_fail;
48243 swig_obj[0] = args;
48244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48245 if (!SWIG_IsOK(res1)) {
48246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48247 }
48248 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48249 {
48250 PyThreadState* __tstate = wxPyBeginAllowThreads();
48251 result = (int)(arg1)->GetCols();
48252 wxPyEndAllowThreads(__tstate);
48253 if (PyErr_Occurred()) SWIG_fail;
48254 }
48255 resultobj = SWIG_From_int(static_cast< int >(result));
48256 return resultobj;
48257 fail:
48258 return NULL;
48259 }
48260
48261
48262 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48263 PyObject *resultobj = 0;
48264 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48265 int result;
48266 void *argp1 = 0 ;
48267 int res1 = 0 ;
48268 PyObject *swig_obj[1] ;
48269
48270 if (!args) SWIG_fail;
48271 swig_obj[0] = args;
48272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48275 }
48276 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48277 {
48278 PyThreadState* __tstate = wxPyBeginAllowThreads();
48279 result = (int)(arg1)->GetRows();
48280 wxPyEndAllowThreads(__tstate);
48281 if (PyErr_Occurred()) SWIG_fail;
48282 }
48283 resultobj = SWIG_From_int(static_cast< int >(result));
48284 return resultobj;
48285 fail:
48286 return NULL;
48287 }
48288
48289
48290 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48291 PyObject *resultobj = 0;
48292 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48293 int result;
48294 void *argp1 = 0 ;
48295 int res1 = 0 ;
48296 PyObject *swig_obj[1] ;
48297
48298 if (!args) SWIG_fail;
48299 swig_obj[0] = args;
48300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48301 if (!SWIG_IsOK(res1)) {
48302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48303 }
48304 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48305 {
48306 PyThreadState* __tstate = wxPyBeginAllowThreads();
48307 result = (int)(arg1)->GetVGap();
48308 wxPyEndAllowThreads(__tstate);
48309 if (PyErr_Occurred()) SWIG_fail;
48310 }
48311 resultobj = SWIG_From_int(static_cast< int >(result));
48312 return resultobj;
48313 fail:
48314 return NULL;
48315 }
48316
48317
48318 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48319 PyObject *resultobj = 0;
48320 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48321 int result;
48322 void *argp1 = 0 ;
48323 int res1 = 0 ;
48324 PyObject *swig_obj[1] ;
48325
48326 if (!args) SWIG_fail;
48327 swig_obj[0] = args;
48328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48329 if (!SWIG_IsOK(res1)) {
48330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48331 }
48332 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48333 {
48334 PyThreadState* __tstate = wxPyBeginAllowThreads();
48335 result = (int)(arg1)->GetHGap();
48336 wxPyEndAllowThreads(__tstate);
48337 if (PyErr_Occurred()) SWIG_fail;
48338 }
48339 resultobj = SWIG_From_int(static_cast< int >(result));
48340 return resultobj;
48341 fail:
48342 return NULL;
48343 }
48344
48345
48346 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48347 PyObject *obj;
48348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48349 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48350 return SWIG_Py_Void();
48351 }
48352
48353 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48354 return SWIG_Python_InitShadowInstance(args);
48355 }
48356
48357 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48358 PyObject *resultobj = 0;
48359 int arg1 = (int) 1 ;
48360 int arg2 = (int) 0 ;
48361 int arg3 = (int) 0 ;
48362 int arg4 = (int) 0 ;
48363 wxFlexGridSizer *result = 0 ;
48364 int val1 ;
48365 int ecode1 = 0 ;
48366 int val2 ;
48367 int ecode2 = 0 ;
48368 int val3 ;
48369 int ecode3 = 0 ;
48370 int val4 ;
48371 int ecode4 = 0 ;
48372 PyObject * obj0 = 0 ;
48373 PyObject * obj1 = 0 ;
48374 PyObject * obj2 = 0 ;
48375 PyObject * obj3 = 0 ;
48376 char * kwnames[] = {
48377 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48378 };
48379
48380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48381 if (obj0) {
48382 ecode1 = SWIG_AsVal_int(obj0, &val1);
48383 if (!SWIG_IsOK(ecode1)) {
48384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48385 }
48386 arg1 = static_cast< int >(val1);
48387 }
48388 if (obj1) {
48389 ecode2 = SWIG_AsVal_int(obj1, &val2);
48390 if (!SWIG_IsOK(ecode2)) {
48391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48392 }
48393 arg2 = static_cast< int >(val2);
48394 }
48395 if (obj2) {
48396 ecode3 = SWIG_AsVal_int(obj2, &val3);
48397 if (!SWIG_IsOK(ecode3)) {
48398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48399 }
48400 arg3 = static_cast< int >(val3);
48401 }
48402 if (obj3) {
48403 ecode4 = SWIG_AsVal_int(obj3, &val4);
48404 if (!SWIG_IsOK(ecode4)) {
48405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48406 }
48407 arg4 = static_cast< int >(val4);
48408 }
48409 {
48410 PyThreadState* __tstate = wxPyBeginAllowThreads();
48411 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48412 wxPyEndAllowThreads(__tstate);
48413 if (PyErr_Occurred()) SWIG_fail;
48414 }
48415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48416 return resultobj;
48417 fail:
48418 return NULL;
48419 }
48420
48421
48422 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48423 PyObject *resultobj = 0;
48424 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48425 size_t arg2 ;
48426 int arg3 = (int) 0 ;
48427 void *argp1 = 0 ;
48428 int res1 = 0 ;
48429 size_t val2 ;
48430 int ecode2 = 0 ;
48431 int val3 ;
48432 int ecode3 = 0 ;
48433 PyObject * obj0 = 0 ;
48434 PyObject * obj1 = 0 ;
48435 PyObject * obj2 = 0 ;
48436 char * kwnames[] = {
48437 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48438 };
48439
48440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48442 if (!SWIG_IsOK(res1)) {
48443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48444 }
48445 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48446 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48447 if (!SWIG_IsOK(ecode2)) {
48448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48449 }
48450 arg2 = static_cast< size_t >(val2);
48451 if (obj2) {
48452 ecode3 = SWIG_AsVal_int(obj2, &val3);
48453 if (!SWIG_IsOK(ecode3)) {
48454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48455 }
48456 arg3 = static_cast< int >(val3);
48457 }
48458 {
48459 PyThreadState* __tstate = wxPyBeginAllowThreads();
48460 (arg1)->AddGrowableRow(arg2,arg3);
48461 wxPyEndAllowThreads(__tstate);
48462 if (PyErr_Occurred()) SWIG_fail;
48463 }
48464 resultobj = SWIG_Py_Void();
48465 return resultobj;
48466 fail:
48467 return NULL;
48468 }
48469
48470
48471 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48472 PyObject *resultobj = 0;
48473 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48474 size_t arg2 ;
48475 void *argp1 = 0 ;
48476 int res1 = 0 ;
48477 size_t val2 ;
48478 int ecode2 = 0 ;
48479 PyObject * obj0 = 0 ;
48480 PyObject * obj1 = 0 ;
48481 char * kwnames[] = {
48482 (char *) "self",(char *) "idx", NULL
48483 };
48484
48485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48487 if (!SWIG_IsOK(res1)) {
48488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48489 }
48490 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48491 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48492 if (!SWIG_IsOK(ecode2)) {
48493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48494 }
48495 arg2 = static_cast< size_t >(val2);
48496 {
48497 PyThreadState* __tstate = wxPyBeginAllowThreads();
48498 (arg1)->RemoveGrowableRow(arg2);
48499 wxPyEndAllowThreads(__tstate);
48500 if (PyErr_Occurred()) SWIG_fail;
48501 }
48502 resultobj = SWIG_Py_Void();
48503 return resultobj;
48504 fail:
48505 return NULL;
48506 }
48507
48508
48509 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48510 PyObject *resultobj = 0;
48511 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48512 size_t arg2 ;
48513 int arg3 = (int) 0 ;
48514 void *argp1 = 0 ;
48515 int res1 = 0 ;
48516 size_t val2 ;
48517 int ecode2 = 0 ;
48518 int val3 ;
48519 int ecode3 = 0 ;
48520 PyObject * obj0 = 0 ;
48521 PyObject * obj1 = 0 ;
48522 PyObject * obj2 = 0 ;
48523 char * kwnames[] = {
48524 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48525 };
48526
48527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48529 if (!SWIG_IsOK(res1)) {
48530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48531 }
48532 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48533 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48534 if (!SWIG_IsOK(ecode2)) {
48535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48536 }
48537 arg2 = static_cast< size_t >(val2);
48538 if (obj2) {
48539 ecode3 = SWIG_AsVal_int(obj2, &val3);
48540 if (!SWIG_IsOK(ecode3)) {
48541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48542 }
48543 arg3 = static_cast< int >(val3);
48544 }
48545 {
48546 PyThreadState* __tstate = wxPyBeginAllowThreads();
48547 (arg1)->AddGrowableCol(arg2,arg3);
48548 wxPyEndAllowThreads(__tstate);
48549 if (PyErr_Occurred()) SWIG_fail;
48550 }
48551 resultobj = SWIG_Py_Void();
48552 return resultobj;
48553 fail:
48554 return NULL;
48555 }
48556
48557
48558 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48559 PyObject *resultobj = 0;
48560 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48561 size_t arg2 ;
48562 void *argp1 = 0 ;
48563 int res1 = 0 ;
48564 size_t val2 ;
48565 int ecode2 = 0 ;
48566 PyObject * obj0 = 0 ;
48567 PyObject * obj1 = 0 ;
48568 char * kwnames[] = {
48569 (char *) "self",(char *) "idx", NULL
48570 };
48571
48572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48574 if (!SWIG_IsOK(res1)) {
48575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48576 }
48577 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48578 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48579 if (!SWIG_IsOK(ecode2)) {
48580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48581 }
48582 arg2 = static_cast< size_t >(val2);
48583 {
48584 PyThreadState* __tstate = wxPyBeginAllowThreads();
48585 (arg1)->RemoveGrowableCol(arg2);
48586 wxPyEndAllowThreads(__tstate);
48587 if (PyErr_Occurred()) SWIG_fail;
48588 }
48589 resultobj = SWIG_Py_Void();
48590 return resultobj;
48591 fail:
48592 return NULL;
48593 }
48594
48595
48596 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48597 PyObject *resultobj = 0;
48598 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48599 int arg2 ;
48600 void *argp1 = 0 ;
48601 int res1 = 0 ;
48602 int val2 ;
48603 int ecode2 = 0 ;
48604 PyObject * obj0 = 0 ;
48605 PyObject * obj1 = 0 ;
48606 char * kwnames[] = {
48607 (char *) "self",(char *) "direction", NULL
48608 };
48609
48610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48612 if (!SWIG_IsOK(res1)) {
48613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48614 }
48615 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48616 ecode2 = SWIG_AsVal_int(obj1, &val2);
48617 if (!SWIG_IsOK(ecode2)) {
48618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48619 }
48620 arg2 = static_cast< int >(val2);
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 (arg1)->SetFlexibleDirection(arg2);
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_Py_Void();
48628 return resultobj;
48629 fail:
48630 return NULL;
48631 }
48632
48633
48634 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 PyObject *resultobj = 0;
48636 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48637 int result;
48638 void *argp1 = 0 ;
48639 int res1 = 0 ;
48640 PyObject *swig_obj[1] ;
48641
48642 if (!args) SWIG_fail;
48643 swig_obj[0] = args;
48644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48647 }
48648 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 result = (int)(arg1)->GetFlexibleDirection();
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 resultobj = SWIG_From_int(static_cast< int >(result));
48656 return resultobj;
48657 fail:
48658 return NULL;
48659 }
48660
48661
48662 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48663 PyObject *resultobj = 0;
48664 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48665 wxFlexSizerGrowMode arg2 ;
48666 void *argp1 = 0 ;
48667 int res1 = 0 ;
48668 int val2 ;
48669 int ecode2 = 0 ;
48670 PyObject * obj0 = 0 ;
48671 PyObject * obj1 = 0 ;
48672 char * kwnames[] = {
48673 (char *) "self",(char *) "mode", NULL
48674 };
48675
48676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48678 if (!SWIG_IsOK(res1)) {
48679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48680 }
48681 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48682 ecode2 = SWIG_AsVal_int(obj1, &val2);
48683 if (!SWIG_IsOK(ecode2)) {
48684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48685 }
48686 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48687 {
48688 PyThreadState* __tstate = wxPyBeginAllowThreads();
48689 (arg1)->SetNonFlexibleGrowMode(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_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48701 PyObject *resultobj = 0;
48702 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48703 wxFlexSizerGrowMode result;
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_wxFlexGridSizer, 0 | 0 );
48711 if (!SWIG_IsOK(res1)) {
48712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48713 }
48714 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48715 {
48716 PyThreadState* __tstate = wxPyBeginAllowThreads();
48717 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48718 wxPyEndAllowThreads(__tstate);
48719 if (PyErr_Occurred()) SWIG_fail;
48720 }
48721 resultobj = SWIG_From_int(static_cast< int >(result));
48722 return resultobj;
48723 fail:
48724 return NULL;
48725 }
48726
48727
48728 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48729 PyObject *resultobj = 0;
48730 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48731 wxArrayInt *result = 0 ;
48732 void *argp1 = 0 ;
48733 int res1 = 0 ;
48734 PyObject *swig_obj[1] ;
48735
48736 if (!args) SWIG_fail;
48737 swig_obj[0] = args;
48738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48739 if (!SWIG_IsOK(res1)) {
48740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48741 }
48742 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48743 {
48744 PyThreadState* __tstate = wxPyBeginAllowThreads();
48745 {
48746 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48747 result = (wxArrayInt *) &_result_ref;
48748 }
48749 wxPyEndAllowThreads(__tstate);
48750 if (PyErr_Occurred()) SWIG_fail;
48751 }
48752 {
48753 resultobj = PyList_New(0);
48754 size_t idx;
48755 for (idx = 0; idx < result->GetCount(); idx += 1) {
48756 PyObject* val = PyInt_FromLong( result->Item(idx) );
48757 PyList_Append(resultobj, val);
48758 Py_DECREF(val);
48759 }
48760 }
48761 return resultobj;
48762 fail:
48763 return NULL;
48764 }
48765
48766
48767 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48768 PyObject *resultobj = 0;
48769 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48770 wxArrayInt *result = 0 ;
48771 void *argp1 = 0 ;
48772 int res1 = 0 ;
48773 PyObject *swig_obj[1] ;
48774
48775 if (!args) SWIG_fail;
48776 swig_obj[0] = args;
48777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48778 if (!SWIG_IsOK(res1)) {
48779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48780 }
48781 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48782 {
48783 PyThreadState* __tstate = wxPyBeginAllowThreads();
48784 {
48785 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48786 result = (wxArrayInt *) &_result_ref;
48787 }
48788 wxPyEndAllowThreads(__tstate);
48789 if (PyErr_Occurred()) SWIG_fail;
48790 }
48791 {
48792 resultobj = PyList_New(0);
48793 size_t idx;
48794 for (idx = 0; idx < result->GetCount(); idx += 1) {
48795 PyObject* val = PyInt_FromLong( result->Item(idx) );
48796 PyList_Append(resultobj, val);
48797 Py_DECREF(val);
48798 }
48799 }
48800 return resultobj;
48801 fail:
48802 return NULL;
48803 }
48804
48805
48806 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48807 PyObject *obj;
48808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48809 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48810 return SWIG_Py_Void();
48811 }
48812
48813 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48814 return SWIG_Python_InitShadowInstance(args);
48815 }
48816
48817 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48818 PyObject *resultobj = 0;
48819 wxStdDialogButtonSizer *result = 0 ;
48820
48821 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48822 {
48823 PyThreadState* __tstate = wxPyBeginAllowThreads();
48824 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48825 wxPyEndAllowThreads(__tstate);
48826 if (PyErr_Occurred()) SWIG_fail;
48827 }
48828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48829 return resultobj;
48830 fail:
48831 return NULL;
48832 }
48833
48834
48835 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48836 PyObject *resultobj = 0;
48837 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48838 wxButton *arg2 = (wxButton *) 0 ;
48839 void *argp1 = 0 ;
48840 int res1 = 0 ;
48841 void *argp2 = 0 ;
48842 int res2 = 0 ;
48843 PyObject * obj0 = 0 ;
48844 PyObject * obj1 = 0 ;
48845 char * kwnames[] = {
48846 (char *) "self",(char *) "button", NULL
48847 };
48848
48849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48851 if (!SWIG_IsOK(res1)) {
48852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48853 }
48854 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48856 if (!SWIG_IsOK(res2)) {
48857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48858 }
48859 arg2 = reinterpret_cast< wxButton * >(argp2);
48860 {
48861 PyThreadState* __tstate = wxPyBeginAllowThreads();
48862 (arg1)->AddButton(arg2);
48863 wxPyEndAllowThreads(__tstate);
48864 if (PyErr_Occurred()) SWIG_fail;
48865 }
48866 resultobj = SWIG_Py_Void();
48867 return resultobj;
48868 fail:
48869 return NULL;
48870 }
48871
48872
48873 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48874 PyObject *resultobj = 0;
48875 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48876 void *argp1 = 0 ;
48877 int res1 = 0 ;
48878 PyObject *swig_obj[1] ;
48879
48880 if (!args) SWIG_fail;
48881 swig_obj[0] = args;
48882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48883 if (!SWIG_IsOK(res1)) {
48884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48885 }
48886 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48887 {
48888 PyThreadState* __tstate = wxPyBeginAllowThreads();
48889 (arg1)->Realize();
48890 wxPyEndAllowThreads(__tstate);
48891 if (PyErr_Occurred()) SWIG_fail;
48892 }
48893 resultobj = SWIG_Py_Void();
48894 return resultobj;
48895 fail:
48896 return NULL;
48897 }
48898
48899
48900 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48901 PyObject *resultobj = 0;
48902 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48903 wxButton *arg2 = (wxButton *) 0 ;
48904 void *argp1 = 0 ;
48905 int res1 = 0 ;
48906 void *argp2 = 0 ;
48907 int res2 = 0 ;
48908 PyObject * obj0 = 0 ;
48909 PyObject * obj1 = 0 ;
48910 char * kwnames[] = {
48911 (char *) "self",(char *) "button", NULL
48912 };
48913
48914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48916 if (!SWIG_IsOK(res1)) {
48917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48918 }
48919 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48921 if (!SWIG_IsOK(res2)) {
48922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48923 }
48924 arg2 = reinterpret_cast< wxButton * >(argp2);
48925 {
48926 PyThreadState* __tstate = wxPyBeginAllowThreads();
48927 (arg1)->SetAffirmativeButton(arg2);
48928 wxPyEndAllowThreads(__tstate);
48929 if (PyErr_Occurred()) SWIG_fail;
48930 }
48931 resultobj = SWIG_Py_Void();
48932 return resultobj;
48933 fail:
48934 return NULL;
48935 }
48936
48937
48938 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48939 PyObject *resultobj = 0;
48940 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48941 wxButton *arg2 = (wxButton *) 0 ;
48942 void *argp1 = 0 ;
48943 int res1 = 0 ;
48944 void *argp2 = 0 ;
48945 int res2 = 0 ;
48946 PyObject * obj0 = 0 ;
48947 PyObject * obj1 = 0 ;
48948 char * kwnames[] = {
48949 (char *) "self",(char *) "button", NULL
48950 };
48951
48952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48954 if (!SWIG_IsOK(res1)) {
48955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48956 }
48957 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48958 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48959 if (!SWIG_IsOK(res2)) {
48960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48961 }
48962 arg2 = reinterpret_cast< wxButton * >(argp2);
48963 {
48964 PyThreadState* __tstate = wxPyBeginAllowThreads();
48965 (arg1)->SetNegativeButton(arg2);
48966 wxPyEndAllowThreads(__tstate);
48967 if (PyErr_Occurred()) SWIG_fail;
48968 }
48969 resultobj = SWIG_Py_Void();
48970 return resultobj;
48971 fail:
48972 return NULL;
48973 }
48974
48975
48976 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48977 PyObject *resultobj = 0;
48978 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48979 wxButton *arg2 = (wxButton *) 0 ;
48980 void *argp1 = 0 ;
48981 int res1 = 0 ;
48982 void *argp2 = 0 ;
48983 int res2 = 0 ;
48984 PyObject * obj0 = 0 ;
48985 PyObject * obj1 = 0 ;
48986 char * kwnames[] = {
48987 (char *) "self",(char *) "button", NULL
48988 };
48989
48990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48992 if (!SWIG_IsOK(res1)) {
48993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48994 }
48995 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48997 if (!SWIG_IsOK(res2)) {
48998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48999 }
49000 arg2 = reinterpret_cast< wxButton * >(argp2);
49001 {
49002 PyThreadState* __tstate = wxPyBeginAllowThreads();
49003 (arg1)->SetCancelButton(arg2);
49004 wxPyEndAllowThreads(__tstate);
49005 if (PyErr_Occurred()) SWIG_fail;
49006 }
49007 resultobj = SWIG_Py_Void();
49008 return resultobj;
49009 fail:
49010 return NULL;
49011 }
49012
49013
49014 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49015 PyObject *resultobj = 0;
49016 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49017 wxButton *result = 0 ;
49018 void *argp1 = 0 ;
49019 int res1 = 0 ;
49020 PyObject *swig_obj[1] ;
49021
49022 if (!args) SWIG_fail;
49023 swig_obj[0] = args;
49024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49025 if (!SWIG_IsOK(res1)) {
49026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49027 }
49028 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49029 {
49030 PyThreadState* __tstate = wxPyBeginAllowThreads();
49031 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49032 wxPyEndAllowThreads(__tstate);
49033 if (PyErr_Occurred()) SWIG_fail;
49034 }
49035 {
49036 resultobj = wxPyMake_wxObject(result, (bool)0);
49037 }
49038 return resultobj;
49039 fail:
49040 return NULL;
49041 }
49042
49043
49044 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49045 PyObject *resultobj = 0;
49046 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49047 wxButton *result = 0 ;
49048 void *argp1 = 0 ;
49049 int res1 = 0 ;
49050 PyObject *swig_obj[1] ;
49051
49052 if (!args) SWIG_fail;
49053 swig_obj[0] = args;
49054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49055 if (!SWIG_IsOK(res1)) {
49056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49057 }
49058 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49059 {
49060 PyThreadState* __tstate = wxPyBeginAllowThreads();
49061 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49062 wxPyEndAllowThreads(__tstate);
49063 if (PyErr_Occurred()) SWIG_fail;
49064 }
49065 {
49066 resultobj = wxPyMake_wxObject(result, (bool)0);
49067 }
49068 return resultobj;
49069 fail:
49070 return NULL;
49071 }
49072
49073
49074 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49075 PyObject *resultobj = 0;
49076 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49077 wxButton *result = 0 ;
49078 void *argp1 = 0 ;
49079 int res1 = 0 ;
49080 PyObject *swig_obj[1] ;
49081
49082 if (!args) SWIG_fail;
49083 swig_obj[0] = args;
49084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49085 if (!SWIG_IsOK(res1)) {
49086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49087 }
49088 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49089 {
49090 PyThreadState* __tstate = wxPyBeginAllowThreads();
49091 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49092 wxPyEndAllowThreads(__tstate);
49093 if (PyErr_Occurred()) SWIG_fail;
49094 }
49095 {
49096 resultobj = wxPyMake_wxObject(result, (bool)0);
49097 }
49098 return resultobj;
49099 fail:
49100 return NULL;
49101 }
49102
49103
49104 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49105 PyObject *resultobj = 0;
49106 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49107 wxButton *result = 0 ;
49108 void *argp1 = 0 ;
49109 int res1 = 0 ;
49110 PyObject *swig_obj[1] ;
49111
49112 if (!args) SWIG_fail;
49113 swig_obj[0] = args;
49114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49115 if (!SWIG_IsOK(res1)) {
49116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49117 }
49118 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49119 {
49120 PyThreadState* __tstate = wxPyBeginAllowThreads();
49121 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49122 wxPyEndAllowThreads(__tstate);
49123 if (PyErr_Occurred()) SWIG_fail;
49124 }
49125 {
49126 resultobj = wxPyMake_wxObject(result, (bool)0);
49127 }
49128 return resultobj;
49129 fail:
49130 return NULL;
49131 }
49132
49133
49134 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49135 PyObject *resultobj = 0;
49136 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49137 wxButton *result = 0 ;
49138 void *argp1 = 0 ;
49139 int res1 = 0 ;
49140 PyObject *swig_obj[1] ;
49141
49142 if (!args) SWIG_fail;
49143 swig_obj[0] = args;
49144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49145 if (!SWIG_IsOK(res1)) {
49146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49147 }
49148 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49149 {
49150 PyThreadState* __tstate = wxPyBeginAllowThreads();
49151 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49152 wxPyEndAllowThreads(__tstate);
49153 if (PyErr_Occurred()) SWIG_fail;
49154 }
49155 {
49156 resultobj = wxPyMake_wxObject(result, (bool)0);
49157 }
49158 return resultobj;
49159 fail:
49160 return NULL;
49161 }
49162
49163
49164 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49165 PyObject *obj;
49166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49167 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49168 return SWIG_Py_Void();
49169 }
49170
49171 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49172 return SWIG_Python_InitShadowInstance(args);
49173 }
49174
49175 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49176 PyObject *resultobj = 0;
49177 int arg1 = (int) 0 ;
49178 int arg2 = (int) 0 ;
49179 wxGBPosition *result = 0 ;
49180 int val1 ;
49181 int ecode1 = 0 ;
49182 int val2 ;
49183 int ecode2 = 0 ;
49184 PyObject * obj0 = 0 ;
49185 PyObject * obj1 = 0 ;
49186 char * kwnames[] = {
49187 (char *) "row",(char *) "col", NULL
49188 };
49189
49190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49191 if (obj0) {
49192 ecode1 = SWIG_AsVal_int(obj0, &val1);
49193 if (!SWIG_IsOK(ecode1)) {
49194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49195 }
49196 arg1 = static_cast< int >(val1);
49197 }
49198 if (obj1) {
49199 ecode2 = SWIG_AsVal_int(obj1, &val2);
49200 if (!SWIG_IsOK(ecode2)) {
49201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49202 }
49203 arg2 = static_cast< int >(val2);
49204 }
49205 {
49206 PyThreadState* __tstate = wxPyBeginAllowThreads();
49207 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49208 wxPyEndAllowThreads(__tstate);
49209 if (PyErr_Occurred()) SWIG_fail;
49210 }
49211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49212 return resultobj;
49213 fail:
49214 return NULL;
49215 }
49216
49217
49218 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49219 PyObject *resultobj = 0;
49220 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49221 void *argp1 = 0 ;
49222 int res1 = 0 ;
49223 PyObject *swig_obj[1] ;
49224
49225 if (!args) SWIG_fail;
49226 swig_obj[0] = args;
49227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49228 if (!SWIG_IsOK(res1)) {
49229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49230 }
49231 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49232 {
49233 PyThreadState* __tstate = wxPyBeginAllowThreads();
49234 delete arg1;
49235
49236 wxPyEndAllowThreads(__tstate);
49237 if (PyErr_Occurred()) SWIG_fail;
49238 }
49239 resultobj = SWIG_Py_Void();
49240 return resultobj;
49241 fail:
49242 return NULL;
49243 }
49244
49245
49246 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49247 PyObject *resultobj = 0;
49248 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49249 int result;
49250 void *argp1 = 0 ;
49251 int res1 = 0 ;
49252 PyObject *swig_obj[1] ;
49253
49254 if (!args) SWIG_fail;
49255 swig_obj[0] = args;
49256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49257 if (!SWIG_IsOK(res1)) {
49258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49259 }
49260 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49261 {
49262 PyThreadState* __tstate = wxPyBeginAllowThreads();
49263 result = (int)((wxGBPosition const *)arg1)->GetRow();
49264 wxPyEndAllowThreads(__tstate);
49265 if (PyErr_Occurred()) SWIG_fail;
49266 }
49267 resultobj = SWIG_From_int(static_cast< int >(result));
49268 return resultobj;
49269 fail:
49270 return NULL;
49271 }
49272
49273
49274 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49275 PyObject *resultobj = 0;
49276 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49277 int result;
49278 void *argp1 = 0 ;
49279 int res1 = 0 ;
49280 PyObject *swig_obj[1] ;
49281
49282 if (!args) SWIG_fail;
49283 swig_obj[0] = args;
49284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49285 if (!SWIG_IsOK(res1)) {
49286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49287 }
49288 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49289 {
49290 PyThreadState* __tstate = wxPyBeginAllowThreads();
49291 result = (int)((wxGBPosition const *)arg1)->GetCol();
49292 wxPyEndAllowThreads(__tstate);
49293 if (PyErr_Occurred()) SWIG_fail;
49294 }
49295 resultobj = SWIG_From_int(static_cast< int >(result));
49296 return resultobj;
49297 fail:
49298 return NULL;
49299 }
49300
49301
49302 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49303 PyObject *resultobj = 0;
49304 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49305 int arg2 ;
49306 void *argp1 = 0 ;
49307 int res1 = 0 ;
49308 int val2 ;
49309 int ecode2 = 0 ;
49310 PyObject * obj0 = 0 ;
49311 PyObject * obj1 = 0 ;
49312 char * kwnames[] = {
49313 (char *) "self",(char *) "row", NULL
49314 };
49315
49316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49318 if (!SWIG_IsOK(res1)) {
49319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49320 }
49321 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49322 ecode2 = SWIG_AsVal_int(obj1, &val2);
49323 if (!SWIG_IsOK(ecode2)) {
49324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49325 }
49326 arg2 = static_cast< int >(val2);
49327 {
49328 PyThreadState* __tstate = wxPyBeginAllowThreads();
49329 (arg1)->SetRow(arg2);
49330 wxPyEndAllowThreads(__tstate);
49331 if (PyErr_Occurred()) SWIG_fail;
49332 }
49333 resultobj = SWIG_Py_Void();
49334 return resultobj;
49335 fail:
49336 return NULL;
49337 }
49338
49339
49340 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49341 PyObject *resultobj = 0;
49342 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49343 int arg2 ;
49344 void *argp1 = 0 ;
49345 int res1 = 0 ;
49346 int val2 ;
49347 int ecode2 = 0 ;
49348 PyObject * obj0 = 0 ;
49349 PyObject * obj1 = 0 ;
49350 char * kwnames[] = {
49351 (char *) "self",(char *) "col", NULL
49352 };
49353
49354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49356 if (!SWIG_IsOK(res1)) {
49357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49358 }
49359 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49360 ecode2 = SWIG_AsVal_int(obj1, &val2);
49361 if (!SWIG_IsOK(ecode2)) {
49362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49363 }
49364 arg2 = static_cast< int >(val2);
49365 {
49366 PyThreadState* __tstate = wxPyBeginAllowThreads();
49367 (arg1)->SetCol(arg2);
49368 wxPyEndAllowThreads(__tstate);
49369 if (PyErr_Occurred()) SWIG_fail;
49370 }
49371 resultobj = SWIG_Py_Void();
49372 return resultobj;
49373 fail:
49374 return NULL;
49375 }
49376
49377
49378 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49379 PyObject *resultobj = 0;
49380 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49381 PyObject *arg2 = (PyObject *) 0 ;
49382 bool result;
49383 void *argp1 = 0 ;
49384 int res1 = 0 ;
49385 PyObject * obj0 = 0 ;
49386 PyObject * obj1 = 0 ;
49387 char * kwnames[] = {
49388 (char *) "self",(char *) "other", NULL
49389 };
49390
49391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49393 if (!SWIG_IsOK(res1)) {
49394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49395 }
49396 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49397 arg2 = obj1;
49398 {
49399 result = (bool)wxGBPosition___eq__(arg1,arg2);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 {
49403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49404 }
49405 return resultobj;
49406 fail:
49407 return NULL;
49408 }
49409
49410
49411 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49412 PyObject *resultobj = 0;
49413 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49414 PyObject *arg2 = (PyObject *) 0 ;
49415 bool result;
49416 void *argp1 = 0 ;
49417 int res1 = 0 ;
49418 PyObject * obj0 = 0 ;
49419 PyObject * obj1 = 0 ;
49420 char * kwnames[] = {
49421 (char *) "self",(char *) "other", NULL
49422 };
49423
49424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49426 if (!SWIG_IsOK(res1)) {
49427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49428 }
49429 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49430 arg2 = obj1;
49431 {
49432 result = (bool)wxGBPosition___ne__(arg1,arg2);
49433 if (PyErr_Occurred()) SWIG_fail;
49434 }
49435 {
49436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49437 }
49438 return resultobj;
49439 fail:
49440 return NULL;
49441 }
49442
49443
49444 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49445 PyObject *resultobj = 0;
49446 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49447 int arg2 = (int) 0 ;
49448 int arg3 = (int) 0 ;
49449 void *argp1 = 0 ;
49450 int res1 = 0 ;
49451 int val2 ;
49452 int ecode2 = 0 ;
49453 int val3 ;
49454 int ecode3 = 0 ;
49455 PyObject * obj0 = 0 ;
49456 PyObject * obj1 = 0 ;
49457 PyObject * obj2 = 0 ;
49458 char * kwnames[] = {
49459 (char *) "self",(char *) "row",(char *) "col", NULL
49460 };
49461
49462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49464 if (!SWIG_IsOK(res1)) {
49465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49466 }
49467 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49468 if (obj1) {
49469 ecode2 = SWIG_AsVal_int(obj1, &val2);
49470 if (!SWIG_IsOK(ecode2)) {
49471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49472 }
49473 arg2 = static_cast< int >(val2);
49474 }
49475 if (obj2) {
49476 ecode3 = SWIG_AsVal_int(obj2, &val3);
49477 if (!SWIG_IsOK(ecode3)) {
49478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49479 }
49480 arg3 = static_cast< int >(val3);
49481 }
49482 {
49483 PyThreadState* __tstate = wxPyBeginAllowThreads();
49484 wxGBPosition_Set(arg1,arg2,arg3);
49485 wxPyEndAllowThreads(__tstate);
49486 if (PyErr_Occurred()) SWIG_fail;
49487 }
49488 resultobj = SWIG_Py_Void();
49489 return resultobj;
49490 fail:
49491 return NULL;
49492 }
49493
49494
49495 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49496 PyObject *resultobj = 0;
49497 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49498 PyObject *result = 0 ;
49499 void *argp1 = 0 ;
49500 int res1 = 0 ;
49501 PyObject *swig_obj[1] ;
49502
49503 if (!args) SWIG_fail;
49504 swig_obj[0] = args;
49505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49506 if (!SWIG_IsOK(res1)) {
49507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49508 }
49509 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49510 {
49511 PyThreadState* __tstate = wxPyBeginAllowThreads();
49512 result = (PyObject *)wxGBPosition_Get(arg1);
49513 wxPyEndAllowThreads(__tstate);
49514 if (PyErr_Occurred()) SWIG_fail;
49515 }
49516 resultobj = result;
49517 return resultobj;
49518 fail:
49519 return NULL;
49520 }
49521
49522
49523 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49524 PyObject *obj;
49525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49526 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49527 return SWIG_Py_Void();
49528 }
49529
49530 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49531 return SWIG_Python_InitShadowInstance(args);
49532 }
49533
49534 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49535 PyObject *resultobj = 0;
49536 int arg1 = (int) 1 ;
49537 int arg2 = (int) 1 ;
49538 wxGBSpan *result = 0 ;
49539 int val1 ;
49540 int ecode1 = 0 ;
49541 int val2 ;
49542 int ecode2 = 0 ;
49543 PyObject * obj0 = 0 ;
49544 PyObject * obj1 = 0 ;
49545 char * kwnames[] = {
49546 (char *) "rowspan",(char *) "colspan", NULL
49547 };
49548
49549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49550 if (obj0) {
49551 ecode1 = SWIG_AsVal_int(obj0, &val1);
49552 if (!SWIG_IsOK(ecode1)) {
49553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49554 }
49555 arg1 = static_cast< int >(val1);
49556 }
49557 if (obj1) {
49558 ecode2 = SWIG_AsVal_int(obj1, &val2);
49559 if (!SWIG_IsOK(ecode2)) {
49560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49561 }
49562 arg2 = static_cast< int >(val2);
49563 }
49564 {
49565 PyThreadState* __tstate = wxPyBeginAllowThreads();
49566 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49567 wxPyEndAllowThreads(__tstate);
49568 if (PyErr_Occurred()) SWIG_fail;
49569 }
49570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49571 return resultobj;
49572 fail:
49573 return NULL;
49574 }
49575
49576
49577 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49578 PyObject *resultobj = 0;
49579 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49580 void *argp1 = 0 ;
49581 int res1 = 0 ;
49582 PyObject *swig_obj[1] ;
49583
49584 if (!args) SWIG_fail;
49585 swig_obj[0] = args;
49586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49587 if (!SWIG_IsOK(res1)) {
49588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49589 }
49590 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49591 {
49592 PyThreadState* __tstate = wxPyBeginAllowThreads();
49593 delete arg1;
49594
49595 wxPyEndAllowThreads(__tstate);
49596 if (PyErr_Occurred()) SWIG_fail;
49597 }
49598 resultobj = SWIG_Py_Void();
49599 return resultobj;
49600 fail:
49601 return NULL;
49602 }
49603
49604
49605 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49606 PyObject *resultobj = 0;
49607 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49608 int result;
49609 void *argp1 = 0 ;
49610 int res1 = 0 ;
49611 PyObject *swig_obj[1] ;
49612
49613 if (!args) SWIG_fail;
49614 swig_obj[0] = args;
49615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49616 if (!SWIG_IsOK(res1)) {
49617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49618 }
49619 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49620 {
49621 PyThreadState* __tstate = wxPyBeginAllowThreads();
49622 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49623 wxPyEndAllowThreads(__tstate);
49624 if (PyErr_Occurred()) SWIG_fail;
49625 }
49626 resultobj = SWIG_From_int(static_cast< int >(result));
49627 return resultobj;
49628 fail:
49629 return NULL;
49630 }
49631
49632
49633 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49634 PyObject *resultobj = 0;
49635 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49636 int result;
49637 void *argp1 = 0 ;
49638 int res1 = 0 ;
49639 PyObject *swig_obj[1] ;
49640
49641 if (!args) SWIG_fail;
49642 swig_obj[0] = args;
49643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49644 if (!SWIG_IsOK(res1)) {
49645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49646 }
49647 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49648 {
49649 PyThreadState* __tstate = wxPyBeginAllowThreads();
49650 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49651 wxPyEndAllowThreads(__tstate);
49652 if (PyErr_Occurred()) SWIG_fail;
49653 }
49654 resultobj = SWIG_From_int(static_cast< int >(result));
49655 return resultobj;
49656 fail:
49657 return NULL;
49658 }
49659
49660
49661 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49662 PyObject *resultobj = 0;
49663 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49664 int arg2 ;
49665 void *argp1 = 0 ;
49666 int res1 = 0 ;
49667 int val2 ;
49668 int ecode2 = 0 ;
49669 PyObject * obj0 = 0 ;
49670 PyObject * obj1 = 0 ;
49671 char * kwnames[] = {
49672 (char *) "self",(char *) "rowspan", NULL
49673 };
49674
49675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49677 if (!SWIG_IsOK(res1)) {
49678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49679 }
49680 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49681 ecode2 = SWIG_AsVal_int(obj1, &val2);
49682 if (!SWIG_IsOK(ecode2)) {
49683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49684 }
49685 arg2 = static_cast< int >(val2);
49686 {
49687 PyThreadState* __tstate = wxPyBeginAllowThreads();
49688 (arg1)->SetRowspan(arg2);
49689 wxPyEndAllowThreads(__tstate);
49690 if (PyErr_Occurred()) SWIG_fail;
49691 }
49692 resultobj = SWIG_Py_Void();
49693 return resultobj;
49694 fail:
49695 return NULL;
49696 }
49697
49698
49699 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49700 PyObject *resultobj = 0;
49701 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49702 int arg2 ;
49703 void *argp1 = 0 ;
49704 int res1 = 0 ;
49705 int val2 ;
49706 int ecode2 = 0 ;
49707 PyObject * obj0 = 0 ;
49708 PyObject * obj1 = 0 ;
49709 char * kwnames[] = {
49710 (char *) "self",(char *) "colspan", NULL
49711 };
49712
49713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49715 if (!SWIG_IsOK(res1)) {
49716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49717 }
49718 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49719 ecode2 = SWIG_AsVal_int(obj1, &val2);
49720 if (!SWIG_IsOK(ecode2)) {
49721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49722 }
49723 arg2 = static_cast< int >(val2);
49724 {
49725 PyThreadState* __tstate = wxPyBeginAllowThreads();
49726 (arg1)->SetColspan(arg2);
49727 wxPyEndAllowThreads(__tstate);
49728 if (PyErr_Occurred()) SWIG_fail;
49729 }
49730 resultobj = SWIG_Py_Void();
49731 return resultobj;
49732 fail:
49733 return NULL;
49734 }
49735
49736
49737 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49738 PyObject *resultobj = 0;
49739 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49740 PyObject *arg2 = (PyObject *) 0 ;
49741 bool result;
49742 void *argp1 = 0 ;
49743 int res1 = 0 ;
49744 PyObject * obj0 = 0 ;
49745 PyObject * obj1 = 0 ;
49746 char * kwnames[] = {
49747 (char *) "self",(char *) "other", NULL
49748 };
49749
49750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49752 if (!SWIG_IsOK(res1)) {
49753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49754 }
49755 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49756 arg2 = obj1;
49757 {
49758 result = (bool)wxGBSpan___eq__(arg1,arg2);
49759 if (PyErr_Occurred()) SWIG_fail;
49760 }
49761 {
49762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49763 }
49764 return resultobj;
49765 fail:
49766 return NULL;
49767 }
49768
49769
49770 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49771 PyObject *resultobj = 0;
49772 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49773 PyObject *arg2 = (PyObject *) 0 ;
49774 bool result;
49775 void *argp1 = 0 ;
49776 int res1 = 0 ;
49777 PyObject * obj0 = 0 ;
49778 PyObject * obj1 = 0 ;
49779 char * kwnames[] = {
49780 (char *) "self",(char *) "other", NULL
49781 };
49782
49783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49785 if (!SWIG_IsOK(res1)) {
49786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49787 }
49788 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49789 arg2 = obj1;
49790 {
49791 result = (bool)wxGBSpan___ne__(arg1,arg2);
49792 if (PyErr_Occurred()) SWIG_fail;
49793 }
49794 {
49795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49796 }
49797 return resultobj;
49798 fail:
49799 return NULL;
49800 }
49801
49802
49803 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49804 PyObject *resultobj = 0;
49805 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49806 int arg2 = (int) 1 ;
49807 int arg3 = (int) 1 ;
49808 void *argp1 = 0 ;
49809 int res1 = 0 ;
49810 int val2 ;
49811 int ecode2 = 0 ;
49812 int val3 ;
49813 int ecode3 = 0 ;
49814 PyObject * obj0 = 0 ;
49815 PyObject * obj1 = 0 ;
49816 PyObject * obj2 = 0 ;
49817 char * kwnames[] = {
49818 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49819 };
49820
49821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49823 if (!SWIG_IsOK(res1)) {
49824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49825 }
49826 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49827 if (obj1) {
49828 ecode2 = SWIG_AsVal_int(obj1, &val2);
49829 if (!SWIG_IsOK(ecode2)) {
49830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49831 }
49832 arg2 = static_cast< int >(val2);
49833 }
49834 if (obj2) {
49835 ecode3 = SWIG_AsVal_int(obj2, &val3);
49836 if (!SWIG_IsOK(ecode3)) {
49837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49838 }
49839 arg3 = static_cast< int >(val3);
49840 }
49841 {
49842 PyThreadState* __tstate = wxPyBeginAllowThreads();
49843 wxGBSpan_Set(arg1,arg2,arg3);
49844 wxPyEndAllowThreads(__tstate);
49845 if (PyErr_Occurred()) SWIG_fail;
49846 }
49847 resultobj = SWIG_Py_Void();
49848 return resultobj;
49849 fail:
49850 return NULL;
49851 }
49852
49853
49854 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49855 PyObject *resultobj = 0;
49856 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49857 PyObject *result = 0 ;
49858 void *argp1 = 0 ;
49859 int res1 = 0 ;
49860 PyObject *swig_obj[1] ;
49861
49862 if (!args) SWIG_fail;
49863 swig_obj[0] = args;
49864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49865 if (!SWIG_IsOK(res1)) {
49866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49867 }
49868 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49869 {
49870 PyThreadState* __tstate = wxPyBeginAllowThreads();
49871 result = (PyObject *)wxGBSpan_Get(arg1);
49872 wxPyEndAllowThreads(__tstate);
49873 if (PyErr_Occurred()) SWIG_fail;
49874 }
49875 resultobj = result;
49876 return resultobj;
49877 fail:
49878 return NULL;
49879 }
49880
49881
49882 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49883 PyObject *obj;
49884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49885 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49886 return SWIG_Py_Void();
49887 }
49888
49889 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49890 return SWIG_Python_InitShadowInstance(args);
49891 }
49892
49893 SWIGINTERN int DefaultSpan_set(PyObject *) {
49894 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49895 return 1;
49896 }
49897
49898
49899 SWIGINTERN PyObject *DefaultSpan_get(void) {
49900 PyObject *pyobj = 0;
49901
49902 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49903 return pyobj;
49904 }
49905
49906
49907 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49908 PyObject *resultobj = 0;
49909 wxGBSizerItem *result = 0 ;
49910
49911 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49912 {
49913 PyThreadState* __tstate = wxPyBeginAllowThreads();
49914 result = (wxGBSizerItem *)new wxGBSizerItem();
49915 wxPyEndAllowThreads(__tstate);
49916 if (PyErr_Occurred()) SWIG_fail;
49917 }
49918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49919 return resultobj;
49920 fail:
49921 return NULL;
49922 }
49923
49924
49925 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49926 PyObject *resultobj = 0;
49927 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49928 void *argp1 = 0 ;
49929 int res1 = 0 ;
49930 PyObject *swig_obj[1] ;
49931
49932 if (!args) SWIG_fail;
49933 swig_obj[0] = args;
49934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49935 if (!SWIG_IsOK(res1)) {
49936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49937 }
49938 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49939 {
49940 PyThreadState* __tstate = wxPyBeginAllowThreads();
49941 delete arg1;
49942
49943 wxPyEndAllowThreads(__tstate);
49944 if (PyErr_Occurred()) SWIG_fail;
49945 }
49946 resultobj = SWIG_Py_Void();
49947 return resultobj;
49948 fail:
49949 return NULL;
49950 }
49951
49952
49953 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49954 PyObject *resultobj = 0;
49955 wxWindow *arg1 = (wxWindow *) 0 ;
49956 wxGBPosition *arg2 = 0 ;
49957 wxGBSpan *arg3 = 0 ;
49958 int arg4 ;
49959 int arg5 ;
49960 PyObject *arg6 = (PyObject *) NULL ;
49961 wxGBSizerItem *result = 0 ;
49962 void *argp1 = 0 ;
49963 int res1 = 0 ;
49964 wxGBPosition temp2 ;
49965 wxGBSpan temp3 ;
49966 int val4 ;
49967 int ecode4 = 0 ;
49968 int val5 ;
49969 int ecode5 = 0 ;
49970 PyObject * obj0 = 0 ;
49971 PyObject * obj1 = 0 ;
49972 PyObject * obj2 = 0 ;
49973 PyObject * obj3 = 0 ;
49974 PyObject * obj4 = 0 ;
49975 PyObject * obj5 = 0 ;
49976 char * kwnames[] = {
49977 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49978 };
49979
49980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49982 if (!SWIG_IsOK(res1)) {
49983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49984 }
49985 arg1 = reinterpret_cast< wxWindow * >(argp1);
49986 {
49987 arg2 = &temp2;
49988 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49989 }
49990 {
49991 arg3 = &temp3;
49992 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49993 }
49994 ecode4 = SWIG_AsVal_int(obj3, &val4);
49995 if (!SWIG_IsOK(ecode4)) {
49996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49997 }
49998 arg4 = static_cast< int >(val4);
49999 ecode5 = SWIG_AsVal_int(obj4, &val5);
50000 if (!SWIG_IsOK(ecode5)) {
50001 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50002 }
50003 arg5 = static_cast< int >(val5);
50004 if (obj5) {
50005 arg6 = obj5;
50006 }
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50014 return resultobj;
50015 fail:
50016 return NULL;
50017 }
50018
50019
50020 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50021 PyObject *resultobj = 0;
50022 wxSizer *arg1 = (wxSizer *) 0 ;
50023 wxGBPosition *arg2 = 0 ;
50024 wxGBSpan *arg3 = 0 ;
50025 int arg4 ;
50026 int arg5 ;
50027 PyObject *arg6 = (PyObject *) NULL ;
50028 wxGBSizerItem *result = 0 ;
50029 int res1 = 0 ;
50030 wxGBPosition temp2 ;
50031 wxGBSpan temp3 ;
50032 int val4 ;
50033 int ecode4 = 0 ;
50034 int val5 ;
50035 int ecode5 = 0 ;
50036 PyObject * obj0 = 0 ;
50037 PyObject * obj1 = 0 ;
50038 PyObject * obj2 = 0 ;
50039 PyObject * obj3 = 0 ;
50040 PyObject * obj4 = 0 ;
50041 PyObject * obj5 = 0 ;
50042 char * kwnames[] = {
50043 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50044 };
50045
50046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50047 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50048 if (!SWIG_IsOK(res1)) {
50049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50050 }
50051 {
50052 arg2 = &temp2;
50053 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50054 }
50055 {
50056 arg3 = &temp3;
50057 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50058 }
50059 ecode4 = SWIG_AsVal_int(obj3, &val4);
50060 if (!SWIG_IsOK(ecode4)) {
50061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50062 }
50063 arg4 = static_cast< int >(val4);
50064 ecode5 = SWIG_AsVal_int(obj4, &val5);
50065 if (!SWIG_IsOK(ecode5)) {
50066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50067 }
50068 arg5 = static_cast< int >(val5);
50069 if (obj5) {
50070 arg6 = obj5;
50071 }
50072 {
50073 PyThreadState* __tstate = wxPyBeginAllowThreads();
50074 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50075 wxPyEndAllowThreads(__tstate);
50076 if (PyErr_Occurred()) SWIG_fail;
50077 }
50078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50079 return resultobj;
50080 fail:
50081 return NULL;
50082 }
50083
50084
50085 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50086 PyObject *resultobj = 0;
50087 int arg1 ;
50088 int arg2 ;
50089 wxGBPosition *arg3 = 0 ;
50090 wxGBSpan *arg4 = 0 ;
50091 int arg5 ;
50092 int arg6 ;
50093 PyObject *arg7 = (PyObject *) NULL ;
50094 wxGBSizerItem *result = 0 ;
50095 int val1 ;
50096 int ecode1 = 0 ;
50097 int val2 ;
50098 int ecode2 = 0 ;
50099 wxGBPosition temp3 ;
50100 wxGBSpan temp4 ;
50101 int val5 ;
50102 int ecode5 = 0 ;
50103 int val6 ;
50104 int ecode6 = 0 ;
50105 PyObject * obj0 = 0 ;
50106 PyObject * obj1 = 0 ;
50107 PyObject * obj2 = 0 ;
50108 PyObject * obj3 = 0 ;
50109 PyObject * obj4 = 0 ;
50110 PyObject * obj5 = 0 ;
50111 PyObject * obj6 = 0 ;
50112 char * kwnames[] = {
50113 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50114 };
50115
50116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50117 ecode1 = SWIG_AsVal_int(obj0, &val1);
50118 if (!SWIG_IsOK(ecode1)) {
50119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50120 }
50121 arg1 = static_cast< int >(val1);
50122 ecode2 = SWIG_AsVal_int(obj1, &val2);
50123 if (!SWIG_IsOK(ecode2)) {
50124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50125 }
50126 arg2 = static_cast< int >(val2);
50127 {
50128 arg3 = &temp3;
50129 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50130 }
50131 {
50132 arg4 = &temp4;
50133 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50134 }
50135 ecode5 = SWIG_AsVal_int(obj4, &val5);
50136 if (!SWIG_IsOK(ecode5)) {
50137 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50138 }
50139 arg5 = static_cast< int >(val5);
50140 ecode6 = SWIG_AsVal_int(obj5, &val6);
50141 if (!SWIG_IsOK(ecode6)) {
50142 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50143 }
50144 arg6 = static_cast< int >(val6);
50145 if (obj6) {
50146 arg7 = obj6;
50147 }
50148 {
50149 PyThreadState* __tstate = wxPyBeginAllowThreads();
50150 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50151 wxPyEndAllowThreads(__tstate);
50152 if (PyErr_Occurred()) SWIG_fail;
50153 }
50154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50155 return resultobj;
50156 fail:
50157 return NULL;
50158 }
50159
50160
50161 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50162 PyObject *resultobj = 0;
50163 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50164 wxGBPosition result;
50165 void *argp1 = 0 ;
50166 int res1 = 0 ;
50167 PyObject *swig_obj[1] ;
50168
50169 if (!args) SWIG_fail;
50170 swig_obj[0] = args;
50171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50172 if (!SWIG_IsOK(res1)) {
50173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50174 }
50175 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50176 {
50177 PyThreadState* __tstate = wxPyBeginAllowThreads();
50178 result = ((wxGBSizerItem const *)arg1)->GetPos();
50179 wxPyEndAllowThreads(__tstate);
50180 if (PyErr_Occurred()) SWIG_fail;
50181 }
50182 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50183 return resultobj;
50184 fail:
50185 return NULL;
50186 }
50187
50188
50189 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50190 PyObject *resultobj = 0;
50191 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50192 wxGBSpan result;
50193 void *argp1 = 0 ;
50194 int res1 = 0 ;
50195 PyObject *swig_obj[1] ;
50196
50197 if (!args) SWIG_fail;
50198 swig_obj[0] = args;
50199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50200 if (!SWIG_IsOK(res1)) {
50201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50202 }
50203 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50204 {
50205 PyThreadState* __tstate = wxPyBeginAllowThreads();
50206 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50207 wxPyEndAllowThreads(__tstate);
50208 if (PyErr_Occurred()) SWIG_fail;
50209 }
50210 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50211 return resultobj;
50212 fail:
50213 return NULL;
50214 }
50215
50216
50217 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50218 PyObject *resultobj = 0;
50219 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50220 wxGBPosition *arg2 = 0 ;
50221 bool result;
50222 void *argp1 = 0 ;
50223 int res1 = 0 ;
50224 wxGBPosition temp2 ;
50225 PyObject * obj0 = 0 ;
50226 PyObject * obj1 = 0 ;
50227 char * kwnames[] = {
50228 (char *) "self",(char *) "pos", NULL
50229 };
50230
50231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50233 if (!SWIG_IsOK(res1)) {
50234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50235 }
50236 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50237 {
50238 arg2 = &temp2;
50239 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50240 }
50241 {
50242 PyThreadState* __tstate = wxPyBeginAllowThreads();
50243 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50244 wxPyEndAllowThreads(__tstate);
50245 if (PyErr_Occurred()) SWIG_fail;
50246 }
50247 {
50248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50249 }
50250 return resultobj;
50251 fail:
50252 return NULL;
50253 }
50254
50255
50256 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50257 PyObject *resultobj = 0;
50258 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50259 wxGBSpan *arg2 = 0 ;
50260 bool result;
50261 void *argp1 = 0 ;
50262 int res1 = 0 ;
50263 wxGBSpan temp2 ;
50264 PyObject * obj0 = 0 ;
50265 PyObject * obj1 = 0 ;
50266 char * kwnames[] = {
50267 (char *) "self",(char *) "span", NULL
50268 };
50269
50270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50272 if (!SWIG_IsOK(res1)) {
50273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50274 }
50275 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50276 {
50277 arg2 = &temp2;
50278 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50279 }
50280 {
50281 PyThreadState* __tstate = wxPyBeginAllowThreads();
50282 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50283 wxPyEndAllowThreads(__tstate);
50284 if (PyErr_Occurred()) SWIG_fail;
50285 }
50286 {
50287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50288 }
50289 return resultobj;
50290 fail:
50291 return NULL;
50292 }
50293
50294
50295 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50296 PyObject *resultobj = 0;
50297 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50298 wxGBSizerItem *arg2 = 0 ;
50299 bool result;
50300 void *argp1 = 0 ;
50301 int res1 = 0 ;
50302 void *argp2 = 0 ;
50303 int res2 = 0 ;
50304 PyObject * obj0 = 0 ;
50305 PyObject * obj1 = 0 ;
50306 char * kwnames[] = {
50307 (char *) "self",(char *) "other", NULL
50308 };
50309
50310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50312 if (!SWIG_IsOK(res1)) {
50313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50314 }
50315 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50316 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50317 if (!SWIG_IsOK(res2)) {
50318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50319 }
50320 if (!argp2) {
50321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50322 }
50323 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50324 {
50325 PyThreadState* __tstate = wxPyBeginAllowThreads();
50326 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50327 wxPyEndAllowThreads(__tstate);
50328 if (PyErr_Occurred()) SWIG_fail;
50329 }
50330 {
50331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50332 }
50333 return resultobj;
50334 fail:
50335 return NULL;
50336 }
50337
50338
50339 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50340 PyObject *resultobj = 0;
50341 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50342 wxGBPosition *arg2 = 0 ;
50343 wxGBSpan *arg3 = 0 ;
50344 bool result;
50345 void *argp1 = 0 ;
50346 int res1 = 0 ;
50347 wxGBPosition temp2 ;
50348 wxGBSpan temp3 ;
50349 PyObject * obj0 = 0 ;
50350 PyObject * obj1 = 0 ;
50351 PyObject * obj2 = 0 ;
50352 char * kwnames[] = {
50353 (char *) "self",(char *) "pos",(char *) "span", NULL
50354 };
50355
50356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50358 if (!SWIG_IsOK(res1)) {
50359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50360 }
50361 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50362 {
50363 arg2 = &temp2;
50364 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50365 }
50366 {
50367 arg3 = &temp3;
50368 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50369 }
50370 {
50371 PyThreadState* __tstate = wxPyBeginAllowThreads();
50372 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50373 wxPyEndAllowThreads(__tstate);
50374 if (PyErr_Occurred()) SWIG_fail;
50375 }
50376 {
50377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50378 }
50379 return resultobj;
50380 fail:
50381 return NULL;
50382 }
50383
50384
50385 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50386 PyObject *resultobj = 0;
50387 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50388 wxGBPosition result;
50389 void *argp1 = 0 ;
50390 int res1 = 0 ;
50391 PyObject *swig_obj[1] ;
50392
50393 if (!args) SWIG_fail;
50394 swig_obj[0] = args;
50395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50396 if (!SWIG_IsOK(res1)) {
50397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50398 }
50399 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50400 {
50401 PyThreadState* __tstate = wxPyBeginAllowThreads();
50402 result = wxGBSizerItem_GetEndPos(arg1);
50403 wxPyEndAllowThreads(__tstate);
50404 if (PyErr_Occurred()) SWIG_fail;
50405 }
50406 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50407 return resultobj;
50408 fail:
50409 return NULL;
50410 }
50411
50412
50413 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50414 PyObject *resultobj = 0;
50415 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50416 wxGridBagSizer *result = 0 ;
50417 void *argp1 = 0 ;
50418 int res1 = 0 ;
50419 PyObject *swig_obj[1] ;
50420
50421 if (!args) SWIG_fail;
50422 swig_obj[0] = args;
50423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50428 {
50429 PyThreadState* __tstate = wxPyBeginAllowThreads();
50430 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50431 wxPyEndAllowThreads(__tstate);
50432 if (PyErr_Occurred()) SWIG_fail;
50433 }
50434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50435 return resultobj;
50436 fail:
50437 return NULL;
50438 }
50439
50440
50441 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50442 PyObject *resultobj = 0;
50443 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50444 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50445 void *argp1 = 0 ;
50446 int res1 = 0 ;
50447 void *argp2 = 0 ;
50448 int res2 = 0 ;
50449 PyObject * obj0 = 0 ;
50450 PyObject * obj1 = 0 ;
50451 char * kwnames[] = {
50452 (char *) "self",(char *) "sizer", NULL
50453 };
50454
50455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50457 if (!SWIG_IsOK(res1)) {
50458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50459 }
50460 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50462 if (!SWIG_IsOK(res2)) {
50463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50464 }
50465 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50466 {
50467 PyThreadState* __tstate = wxPyBeginAllowThreads();
50468 (arg1)->SetGBSizer(arg2);
50469 wxPyEndAllowThreads(__tstate);
50470 if (PyErr_Occurred()) SWIG_fail;
50471 }
50472 resultobj = SWIG_Py_Void();
50473 return resultobj;
50474 fail:
50475 return NULL;
50476 }
50477
50478
50479 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50480 PyObject *obj;
50481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50482 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50483 return SWIG_Py_Void();
50484 }
50485
50486 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50487 return SWIG_Python_InitShadowInstance(args);
50488 }
50489
50490 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50491 PyObject *resultobj = 0;
50492 int arg1 = (int) 0 ;
50493 int arg2 = (int) 0 ;
50494 wxGridBagSizer *result = 0 ;
50495 int val1 ;
50496 int ecode1 = 0 ;
50497 int val2 ;
50498 int ecode2 = 0 ;
50499 PyObject * obj0 = 0 ;
50500 PyObject * obj1 = 0 ;
50501 char * kwnames[] = {
50502 (char *) "vgap",(char *) "hgap", NULL
50503 };
50504
50505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50506 if (obj0) {
50507 ecode1 = SWIG_AsVal_int(obj0, &val1);
50508 if (!SWIG_IsOK(ecode1)) {
50509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50510 }
50511 arg1 = static_cast< int >(val1);
50512 }
50513 if (obj1) {
50514 ecode2 = SWIG_AsVal_int(obj1, &val2);
50515 if (!SWIG_IsOK(ecode2)) {
50516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50517 }
50518 arg2 = static_cast< int >(val2);
50519 }
50520 {
50521 PyThreadState* __tstate = wxPyBeginAllowThreads();
50522 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50523 wxPyEndAllowThreads(__tstate);
50524 if (PyErr_Occurred()) SWIG_fail;
50525 }
50526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50527 return resultobj;
50528 fail:
50529 return NULL;
50530 }
50531
50532
50533 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50534 PyObject *resultobj = 0;
50535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50536 PyObject *arg2 = (PyObject *) 0 ;
50537 wxGBPosition *arg3 = 0 ;
50538 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50539 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50540 int arg5 = (int) 0 ;
50541 int arg6 = (int) 0 ;
50542 PyObject *arg7 = (PyObject *) NULL ;
50543 wxGBSizerItem *result = 0 ;
50544 void *argp1 = 0 ;
50545 int res1 = 0 ;
50546 wxGBPosition temp3 ;
50547 wxGBSpan temp4 ;
50548 int val5 ;
50549 int ecode5 = 0 ;
50550 int val6 ;
50551 int ecode6 = 0 ;
50552 PyObject * obj0 = 0 ;
50553 PyObject * obj1 = 0 ;
50554 PyObject * obj2 = 0 ;
50555 PyObject * obj3 = 0 ;
50556 PyObject * obj4 = 0 ;
50557 PyObject * obj5 = 0 ;
50558 PyObject * obj6 = 0 ;
50559 char * kwnames[] = {
50560 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50561 };
50562
50563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50565 if (!SWIG_IsOK(res1)) {
50566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50567 }
50568 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50569 arg2 = obj1;
50570 {
50571 arg3 = &temp3;
50572 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50573 }
50574 if (obj3) {
50575 {
50576 arg4 = &temp4;
50577 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50578 }
50579 }
50580 if (obj4) {
50581 ecode5 = SWIG_AsVal_int(obj4, &val5);
50582 if (!SWIG_IsOK(ecode5)) {
50583 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50584 }
50585 arg5 = static_cast< int >(val5);
50586 }
50587 if (obj5) {
50588 ecode6 = SWIG_AsVal_int(obj5, &val6);
50589 if (!SWIG_IsOK(ecode6)) {
50590 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50591 }
50592 arg6 = static_cast< int >(val6);
50593 }
50594 if (obj6) {
50595 arg7 = obj6;
50596 }
50597 {
50598 PyThreadState* __tstate = wxPyBeginAllowThreads();
50599 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50600 wxPyEndAllowThreads(__tstate);
50601 if (PyErr_Occurred()) SWIG_fail;
50602 }
50603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50604 return resultobj;
50605 fail:
50606 return NULL;
50607 }
50608
50609
50610 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50611 PyObject *resultobj = 0;
50612 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50613 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50614 wxGBSizerItem *result = 0 ;
50615 void *argp1 = 0 ;
50616 int res1 = 0 ;
50617 int res2 = 0 ;
50618 PyObject * obj0 = 0 ;
50619 PyObject * obj1 = 0 ;
50620 char * kwnames[] = {
50621 (char *) "self",(char *) "item", NULL
50622 };
50623
50624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50626 if (!SWIG_IsOK(res1)) {
50627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50628 }
50629 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50630 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50631 if (!SWIG_IsOK(res2)) {
50632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50633 }
50634 {
50635 PyThreadState* __tstate = wxPyBeginAllowThreads();
50636 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50637 wxPyEndAllowThreads(__tstate);
50638 if (PyErr_Occurred()) SWIG_fail;
50639 }
50640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50641 return resultobj;
50642 fail:
50643 return NULL;
50644 }
50645
50646
50647 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50648 PyObject *resultobj = 0;
50649 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50650 int arg2 ;
50651 int arg3 ;
50652 wxSize result;
50653 void *argp1 = 0 ;
50654 int res1 = 0 ;
50655 int val2 ;
50656 int ecode2 = 0 ;
50657 int val3 ;
50658 int ecode3 = 0 ;
50659 PyObject * obj0 = 0 ;
50660 PyObject * obj1 = 0 ;
50661 PyObject * obj2 = 0 ;
50662 char * kwnames[] = {
50663 (char *) "self",(char *) "row",(char *) "col", NULL
50664 };
50665
50666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50668 if (!SWIG_IsOK(res1)) {
50669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50670 }
50671 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50672 ecode2 = SWIG_AsVal_int(obj1, &val2);
50673 if (!SWIG_IsOK(ecode2)) {
50674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50675 }
50676 arg2 = static_cast< int >(val2);
50677 ecode3 = SWIG_AsVal_int(obj2, &val3);
50678 if (!SWIG_IsOK(ecode3)) {
50679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50680 }
50681 arg3 = static_cast< int >(val3);
50682 {
50683 PyThreadState* __tstate = wxPyBeginAllowThreads();
50684 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50685 wxPyEndAllowThreads(__tstate);
50686 if (PyErr_Occurred()) SWIG_fail;
50687 }
50688 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50689 return resultobj;
50690 fail:
50691 return NULL;
50692 }
50693
50694
50695 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50696 PyObject *resultobj = 0;
50697 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50698 wxSize result;
50699 void *argp1 = 0 ;
50700 int res1 = 0 ;
50701 PyObject *swig_obj[1] ;
50702
50703 if (!args) SWIG_fail;
50704 swig_obj[0] = args;
50705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50708 }
50709 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50710 {
50711 PyThreadState* __tstate = wxPyBeginAllowThreads();
50712 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50713 wxPyEndAllowThreads(__tstate);
50714 if (PyErr_Occurred()) SWIG_fail;
50715 }
50716 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50717 return resultobj;
50718 fail:
50719 return NULL;
50720 }
50721
50722
50723 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50724 PyObject *resultobj = 0;
50725 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50726 wxSize *arg2 = 0 ;
50727 void *argp1 = 0 ;
50728 int res1 = 0 ;
50729 wxSize temp2 ;
50730 PyObject * obj0 = 0 ;
50731 PyObject * obj1 = 0 ;
50732 char * kwnames[] = {
50733 (char *) "self",(char *) "sz", NULL
50734 };
50735
50736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50738 if (!SWIG_IsOK(res1)) {
50739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50740 }
50741 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50742 {
50743 arg2 = &temp2;
50744 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50745 }
50746 {
50747 PyThreadState* __tstate = wxPyBeginAllowThreads();
50748 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50749 wxPyEndAllowThreads(__tstate);
50750 if (PyErr_Occurred()) SWIG_fail;
50751 }
50752 resultobj = SWIG_Py_Void();
50753 return resultobj;
50754 fail:
50755 return NULL;
50756 }
50757
50758
50759 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50760 PyObject *resultobj = 0;
50761 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50762 wxWindow *arg2 = (wxWindow *) 0 ;
50763 wxGBPosition result;
50764 void *argp1 = 0 ;
50765 int res1 = 0 ;
50766 void *argp2 = 0 ;
50767 int res2 = 0 ;
50768
50769 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50771 if (!SWIG_IsOK(res1)) {
50772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50773 }
50774 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50775 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50776 if (!SWIG_IsOK(res2)) {
50777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50778 }
50779 arg2 = reinterpret_cast< wxWindow * >(argp2);
50780 {
50781 PyThreadState* __tstate = wxPyBeginAllowThreads();
50782 result = (arg1)->GetItemPosition(arg2);
50783 wxPyEndAllowThreads(__tstate);
50784 if (PyErr_Occurred()) SWIG_fail;
50785 }
50786 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50787 return resultobj;
50788 fail:
50789 return NULL;
50790 }
50791
50792
50793 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50794 PyObject *resultobj = 0;
50795 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50796 wxSizer *arg2 = (wxSizer *) 0 ;
50797 wxGBPosition result;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 void *argp2 = 0 ;
50801 int res2 = 0 ;
50802
50803 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50805 if (!SWIG_IsOK(res1)) {
50806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50807 }
50808 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50809 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50810 if (!SWIG_IsOK(res2)) {
50811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50812 }
50813 arg2 = reinterpret_cast< wxSizer * >(argp2);
50814 {
50815 PyThreadState* __tstate = wxPyBeginAllowThreads();
50816 result = (arg1)->GetItemPosition(arg2);
50817 wxPyEndAllowThreads(__tstate);
50818 if (PyErr_Occurred()) SWIG_fail;
50819 }
50820 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50821 return resultobj;
50822 fail:
50823 return NULL;
50824 }
50825
50826
50827 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50828 PyObject *resultobj = 0;
50829 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50830 size_t arg2 ;
50831 wxGBPosition result;
50832 void *argp1 = 0 ;
50833 int res1 = 0 ;
50834 size_t val2 ;
50835 int ecode2 = 0 ;
50836
50837 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50839 if (!SWIG_IsOK(res1)) {
50840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50841 }
50842 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50843 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50844 if (!SWIG_IsOK(ecode2)) {
50845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50846 }
50847 arg2 = static_cast< size_t >(val2);
50848 {
50849 PyThreadState* __tstate = wxPyBeginAllowThreads();
50850 result = (arg1)->GetItemPosition(arg2);
50851 wxPyEndAllowThreads(__tstate);
50852 if (PyErr_Occurred()) SWIG_fail;
50853 }
50854 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50855 return resultobj;
50856 fail:
50857 return NULL;
50858 }
50859
50860
50861 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50862 int argc;
50863 PyObject *argv[3];
50864
50865 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50866 --argc;
50867 if (argc == 2) {
50868 int _v = 0;
50869 {
50870 void *vptr = 0;
50871 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50872 _v = SWIG_CheckState(res);
50873 }
50874 if (!_v) goto check_1;
50875 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50876 }
50877 check_1:
50878
50879 if (argc == 2) {
50880 int _v = 0;
50881 {
50882 void *vptr = 0;
50883 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50884 _v = SWIG_CheckState(res);
50885 }
50886 if (!_v) goto check_2;
50887 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50888 }
50889 check_2:
50890
50891 if (argc == 2) {
50892 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50893 }
50894
50895 fail:
50896 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50897 return NULL;
50898 }
50899
50900
50901 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50902 PyObject *resultobj = 0;
50903 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50904 wxWindow *arg2 = (wxWindow *) 0 ;
50905 wxGBPosition *arg3 = 0 ;
50906 bool result;
50907 void *argp1 = 0 ;
50908 int res1 = 0 ;
50909 void *argp2 = 0 ;
50910 int res2 = 0 ;
50911 wxGBPosition temp3 ;
50912
50913 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50915 if (!SWIG_IsOK(res1)) {
50916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50917 }
50918 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50919 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50920 if (!SWIG_IsOK(res2)) {
50921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50922 }
50923 arg2 = reinterpret_cast< wxWindow * >(argp2);
50924 {
50925 arg3 = &temp3;
50926 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50927 }
50928 {
50929 PyThreadState* __tstate = wxPyBeginAllowThreads();
50930 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50931 wxPyEndAllowThreads(__tstate);
50932 if (PyErr_Occurred()) SWIG_fail;
50933 }
50934 {
50935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50936 }
50937 return resultobj;
50938 fail:
50939 return NULL;
50940 }
50941
50942
50943 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50944 PyObject *resultobj = 0;
50945 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50946 wxSizer *arg2 = (wxSizer *) 0 ;
50947 wxGBPosition *arg3 = 0 ;
50948 bool result;
50949 void *argp1 = 0 ;
50950 int res1 = 0 ;
50951 void *argp2 = 0 ;
50952 int res2 = 0 ;
50953 wxGBPosition temp3 ;
50954
50955 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50957 if (!SWIG_IsOK(res1)) {
50958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50959 }
50960 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50961 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50962 if (!SWIG_IsOK(res2)) {
50963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50964 }
50965 arg2 = reinterpret_cast< wxSizer * >(argp2);
50966 {
50967 arg3 = &temp3;
50968 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50969 }
50970 {
50971 PyThreadState* __tstate = wxPyBeginAllowThreads();
50972 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50973 wxPyEndAllowThreads(__tstate);
50974 if (PyErr_Occurred()) SWIG_fail;
50975 }
50976 {
50977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50978 }
50979 return resultobj;
50980 fail:
50981 return NULL;
50982 }
50983
50984
50985 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50986 PyObject *resultobj = 0;
50987 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50988 size_t arg2 ;
50989 wxGBPosition *arg3 = 0 ;
50990 bool result;
50991 void *argp1 = 0 ;
50992 int res1 = 0 ;
50993 size_t val2 ;
50994 int ecode2 = 0 ;
50995 wxGBPosition temp3 ;
50996
50997 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50999 if (!SWIG_IsOK(res1)) {
51000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51001 }
51002 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51003 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51004 if (!SWIG_IsOK(ecode2)) {
51005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51006 }
51007 arg2 = static_cast< size_t >(val2);
51008 {
51009 arg3 = &temp3;
51010 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51011 }
51012 {
51013 PyThreadState* __tstate = wxPyBeginAllowThreads();
51014 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51015 wxPyEndAllowThreads(__tstate);
51016 if (PyErr_Occurred()) SWIG_fail;
51017 }
51018 {
51019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51020 }
51021 return resultobj;
51022 fail:
51023 return NULL;
51024 }
51025
51026
51027 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51028 int argc;
51029 PyObject *argv[4];
51030
51031 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51032 --argc;
51033 if (argc == 3) {
51034 int _v = 0;
51035 {
51036 void *vptr = 0;
51037 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51038 _v = SWIG_CheckState(res);
51039 }
51040 if (!_v) goto check_1;
51041 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51042 }
51043 check_1:
51044
51045 if (argc == 3) {
51046 int _v = 0;
51047 {
51048 void *vptr = 0;
51049 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51050 _v = SWIG_CheckState(res);
51051 }
51052 if (!_v) goto check_2;
51053 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51054 }
51055 check_2:
51056
51057 if (argc == 3) {
51058 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51059 }
51060
51061 fail:
51062 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51063 return NULL;
51064 }
51065
51066
51067 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51068 PyObject *resultobj = 0;
51069 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51070 wxWindow *arg2 = (wxWindow *) 0 ;
51071 wxGBSpan result;
51072 void *argp1 = 0 ;
51073 int res1 = 0 ;
51074 void *argp2 = 0 ;
51075 int res2 = 0 ;
51076
51077 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51079 if (!SWIG_IsOK(res1)) {
51080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51081 }
51082 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51083 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51084 if (!SWIG_IsOK(res2)) {
51085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51086 }
51087 arg2 = reinterpret_cast< wxWindow * >(argp2);
51088 {
51089 PyThreadState* __tstate = wxPyBeginAllowThreads();
51090 result = (arg1)->GetItemSpan(arg2);
51091 wxPyEndAllowThreads(__tstate);
51092 if (PyErr_Occurred()) SWIG_fail;
51093 }
51094 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51095 return resultobj;
51096 fail:
51097 return NULL;
51098 }
51099
51100
51101 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51102 PyObject *resultobj = 0;
51103 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51104 wxSizer *arg2 = (wxSizer *) 0 ;
51105 wxGBSpan result;
51106 void *argp1 = 0 ;
51107 int res1 = 0 ;
51108 void *argp2 = 0 ;
51109 int res2 = 0 ;
51110
51111 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51113 if (!SWIG_IsOK(res1)) {
51114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51115 }
51116 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51117 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51118 if (!SWIG_IsOK(res2)) {
51119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51120 }
51121 arg2 = reinterpret_cast< wxSizer * >(argp2);
51122 {
51123 PyThreadState* __tstate = wxPyBeginAllowThreads();
51124 result = (arg1)->GetItemSpan(arg2);
51125 wxPyEndAllowThreads(__tstate);
51126 if (PyErr_Occurred()) SWIG_fail;
51127 }
51128 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51129 return resultobj;
51130 fail:
51131 return NULL;
51132 }
51133
51134
51135 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51136 PyObject *resultobj = 0;
51137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51138 size_t arg2 ;
51139 wxGBSpan result;
51140 void *argp1 = 0 ;
51141 int res1 = 0 ;
51142 size_t val2 ;
51143 int ecode2 = 0 ;
51144
51145 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51147 if (!SWIG_IsOK(res1)) {
51148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51149 }
51150 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51151 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51152 if (!SWIG_IsOK(ecode2)) {
51153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51154 }
51155 arg2 = static_cast< size_t >(val2);
51156 {
51157 PyThreadState* __tstate = wxPyBeginAllowThreads();
51158 result = (arg1)->GetItemSpan(arg2);
51159 wxPyEndAllowThreads(__tstate);
51160 if (PyErr_Occurred()) SWIG_fail;
51161 }
51162 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51163 return resultobj;
51164 fail:
51165 return NULL;
51166 }
51167
51168
51169 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51170 int argc;
51171 PyObject *argv[3];
51172
51173 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51174 --argc;
51175 if (argc == 2) {
51176 int _v = 0;
51177 {
51178 void *vptr = 0;
51179 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51180 _v = SWIG_CheckState(res);
51181 }
51182 if (!_v) goto check_1;
51183 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51184 }
51185 check_1:
51186
51187 if (argc == 2) {
51188 int _v = 0;
51189 {
51190 void *vptr = 0;
51191 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51192 _v = SWIG_CheckState(res);
51193 }
51194 if (!_v) goto check_2;
51195 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51196 }
51197 check_2:
51198
51199 if (argc == 2) {
51200 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51201 }
51202
51203 fail:
51204 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51205 return NULL;
51206 }
51207
51208
51209 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51210 PyObject *resultobj = 0;
51211 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51212 wxWindow *arg2 = (wxWindow *) 0 ;
51213 wxGBSpan *arg3 = 0 ;
51214 bool result;
51215 void *argp1 = 0 ;
51216 int res1 = 0 ;
51217 void *argp2 = 0 ;
51218 int res2 = 0 ;
51219 wxGBSpan temp3 ;
51220
51221 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51223 if (!SWIG_IsOK(res1)) {
51224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51225 }
51226 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51227 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51228 if (!SWIG_IsOK(res2)) {
51229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51230 }
51231 arg2 = reinterpret_cast< wxWindow * >(argp2);
51232 {
51233 arg3 = &temp3;
51234 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51235 }
51236 {
51237 PyThreadState* __tstate = wxPyBeginAllowThreads();
51238 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51239 wxPyEndAllowThreads(__tstate);
51240 if (PyErr_Occurred()) SWIG_fail;
51241 }
51242 {
51243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51244 }
51245 return resultobj;
51246 fail:
51247 return NULL;
51248 }
51249
51250
51251 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51252 PyObject *resultobj = 0;
51253 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51254 wxSizer *arg2 = (wxSizer *) 0 ;
51255 wxGBSpan *arg3 = 0 ;
51256 bool result;
51257 void *argp1 = 0 ;
51258 int res1 = 0 ;
51259 void *argp2 = 0 ;
51260 int res2 = 0 ;
51261 wxGBSpan temp3 ;
51262
51263 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51265 if (!SWIG_IsOK(res1)) {
51266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51267 }
51268 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51269 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51270 if (!SWIG_IsOK(res2)) {
51271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51272 }
51273 arg2 = reinterpret_cast< wxSizer * >(argp2);
51274 {
51275 arg3 = &temp3;
51276 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51277 }
51278 {
51279 PyThreadState* __tstate = wxPyBeginAllowThreads();
51280 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51281 wxPyEndAllowThreads(__tstate);
51282 if (PyErr_Occurred()) SWIG_fail;
51283 }
51284 {
51285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51286 }
51287 return resultobj;
51288 fail:
51289 return NULL;
51290 }
51291
51292
51293 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51294 PyObject *resultobj = 0;
51295 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51296 size_t arg2 ;
51297 wxGBSpan *arg3 = 0 ;
51298 bool result;
51299 void *argp1 = 0 ;
51300 int res1 = 0 ;
51301 size_t val2 ;
51302 int ecode2 = 0 ;
51303 wxGBSpan temp3 ;
51304
51305 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51307 if (!SWIG_IsOK(res1)) {
51308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51309 }
51310 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51311 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51312 if (!SWIG_IsOK(ecode2)) {
51313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51314 }
51315 arg2 = static_cast< size_t >(val2);
51316 {
51317 arg3 = &temp3;
51318 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51319 }
51320 {
51321 PyThreadState* __tstate = wxPyBeginAllowThreads();
51322 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51323 wxPyEndAllowThreads(__tstate);
51324 if (PyErr_Occurred()) SWIG_fail;
51325 }
51326 {
51327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51328 }
51329 return resultobj;
51330 fail:
51331 return NULL;
51332 }
51333
51334
51335 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51336 int argc;
51337 PyObject *argv[4];
51338
51339 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51340 --argc;
51341 if (argc == 3) {
51342 int _v = 0;
51343 {
51344 void *vptr = 0;
51345 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51346 _v = SWIG_CheckState(res);
51347 }
51348 if (!_v) goto check_1;
51349 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51350 }
51351 check_1:
51352
51353 if (argc == 3) {
51354 int _v = 0;
51355 {
51356 void *vptr = 0;
51357 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51358 _v = SWIG_CheckState(res);
51359 }
51360 if (!_v) goto check_2;
51361 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51362 }
51363 check_2:
51364
51365 if (argc == 3) {
51366 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51367 }
51368
51369 fail:
51370 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51371 return NULL;
51372 }
51373
51374
51375 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51376 PyObject *resultobj = 0;
51377 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51378 wxWindow *arg2 = (wxWindow *) 0 ;
51379 wxGBSizerItem *result = 0 ;
51380 void *argp1 = 0 ;
51381 int res1 = 0 ;
51382 void *argp2 = 0 ;
51383 int res2 = 0 ;
51384
51385 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51387 if (!SWIG_IsOK(res1)) {
51388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51389 }
51390 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51391 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51392 if (!SWIG_IsOK(res2)) {
51393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51394 }
51395 arg2 = reinterpret_cast< wxWindow * >(argp2);
51396 {
51397 PyThreadState* __tstate = wxPyBeginAllowThreads();
51398 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51399 wxPyEndAllowThreads(__tstate);
51400 if (PyErr_Occurred()) SWIG_fail;
51401 }
51402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51403 return resultobj;
51404 fail:
51405 return NULL;
51406 }
51407
51408
51409 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51410 PyObject *resultobj = 0;
51411 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51412 wxSizer *arg2 = (wxSizer *) 0 ;
51413 wxGBSizerItem *result = 0 ;
51414 void *argp1 = 0 ;
51415 int res1 = 0 ;
51416 void *argp2 = 0 ;
51417 int res2 = 0 ;
51418
51419 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51421 if (!SWIG_IsOK(res1)) {
51422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51423 }
51424 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51425 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51426 if (!SWIG_IsOK(res2)) {
51427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51428 }
51429 arg2 = reinterpret_cast< wxSizer * >(argp2);
51430 {
51431 PyThreadState* __tstate = wxPyBeginAllowThreads();
51432 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51433 wxPyEndAllowThreads(__tstate);
51434 if (PyErr_Occurred()) SWIG_fail;
51435 }
51436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51437 return resultobj;
51438 fail:
51439 return NULL;
51440 }
51441
51442
51443 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51444 int argc;
51445 PyObject *argv[3];
51446
51447 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51448 --argc;
51449 if (argc == 2) {
51450 int _v = 0;
51451 {
51452 void *vptr = 0;
51453 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51454 _v = SWIG_CheckState(res);
51455 }
51456 if (!_v) goto check_1;
51457 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51458 }
51459 check_1:
51460
51461 if (argc == 2) {
51462 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51463 }
51464
51465 fail:
51466 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51467 return NULL;
51468 }
51469
51470
51471 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51472 PyObject *resultobj = 0;
51473 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51474 wxGBPosition *arg2 = 0 ;
51475 wxGBSizerItem *result = 0 ;
51476 void *argp1 = 0 ;
51477 int res1 = 0 ;
51478 wxGBPosition temp2 ;
51479 PyObject * obj0 = 0 ;
51480 PyObject * obj1 = 0 ;
51481 char * kwnames[] = {
51482 (char *) "self",(char *) "pos", NULL
51483 };
51484
51485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51487 if (!SWIG_IsOK(res1)) {
51488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51489 }
51490 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51491 {
51492 arg2 = &temp2;
51493 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51494 }
51495 {
51496 PyThreadState* __tstate = wxPyBeginAllowThreads();
51497 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51498 wxPyEndAllowThreads(__tstate);
51499 if (PyErr_Occurred()) SWIG_fail;
51500 }
51501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51502 return resultobj;
51503 fail:
51504 return NULL;
51505 }
51506
51507
51508 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51509 PyObject *resultobj = 0;
51510 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51511 wxPoint *arg2 = 0 ;
51512 wxGBSizerItem *result = 0 ;
51513 void *argp1 = 0 ;
51514 int res1 = 0 ;
51515 wxPoint temp2 ;
51516 PyObject * obj0 = 0 ;
51517 PyObject * obj1 = 0 ;
51518 char * kwnames[] = {
51519 (char *) "self",(char *) "pt", NULL
51520 };
51521
51522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51524 if (!SWIG_IsOK(res1)) {
51525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51526 }
51527 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51528 {
51529 arg2 = &temp2;
51530 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51531 }
51532 {
51533 PyThreadState* __tstate = wxPyBeginAllowThreads();
51534 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51535 wxPyEndAllowThreads(__tstate);
51536 if (PyErr_Occurred()) SWIG_fail;
51537 }
51538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51539 return resultobj;
51540 fail:
51541 return NULL;
51542 }
51543
51544
51545 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51546 PyObject *resultobj = 0;
51547 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51548 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51549 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51550 bool result;
51551 void *argp1 = 0 ;
51552 int res1 = 0 ;
51553 void *argp2 = 0 ;
51554 int res2 = 0 ;
51555 void *argp3 = 0 ;
51556 int res3 = 0 ;
51557 PyObject * obj0 = 0 ;
51558 PyObject * obj1 = 0 ;
51559 PyObject * obj2 = 0 ;
51560 char * kwnames[] = {
51561 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51562 };
51563
51564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51566 if (!SWIG_IsOK(res1)) {
51567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51568 }
51569 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51571 if (!SWIG_IsOK(res2)) {
51572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51573 }
51574 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51575 if (obj2) {
51576 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51577 if (!SWIG_IsOK(res3)) {
51578 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51579 }
51580 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51581 }
51582 {
51583 PyThreadState* __tstate = wxPyBeginAllowThreads();
51584 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51585 wxPyEndAllowThreads(__tstate);
51586 if (PyErr_Occurred()) SWIG_fail;
51587 }
51588 {
51589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51590 }
51591 return resultobj;
51592 fail:
51593 return NULL;
51594 }
51595
51596
51597 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51598 PyObject *resultobj = 0;
51599 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51600 wxGBPosition *arg2 = 0 ;
51601 wxGBSpan *arg3 = 0 ;
51602 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51603 bool result;
51604 void *argp1 = 0 ;
51605 int res1 = 0 ;
51606 wxGBPosition temp2 ;
51607 wxGBSpan temp3 ;
51608 void *argp4 = 0 ;
51609 int res4 = 0 ;
51610 PyObject * obj0 = 0 ;
51611 PyObject * obj1 = 0 ;
51612 PyObject * obj2 = 0 ;
51613 PyObject * obj3 = 0 ;
51614 char * kwnames[] = {
51615 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51616 };
51617
51618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51620 if (!SWIG_IsOK(res1)) {
51621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51622 }
51623 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51624 {
51625 arg2 = &temp2;
51626 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51627 }
51628 {
51629 arg3 = &temp3;
51630 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51631 }
51632 if (obj3) {
51633 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51634 if (!SWIG_IsOK(res4)) {
51635 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51636 }
51637 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51638 }
51639 {
51640 PyThreadState* __tstate = wxPyBeginAllowThreads();
51641 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51642 wxPyEndAllowThreads(__tstate);
51643 if (PyErr_Occurred()) SWIG_fail;
51644 }
51645 {
51646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51647 }
51648 return resultobj;
51649 fail:
51650 return NULL;
51651 }
51652
51653
51654 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51655 PyObject *obj;
51656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51657 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51658 return SWIG_Py_Void();
51659 }
51660
51661 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51662 return SWIG_Python_InitShadowInstance(args);
51663 }
51664
51665 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51666 PyObject *resultobj = 0;
51667 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51668 wxRelationship arg2 ;
51669 wxWindow *arg3 = (wxWindow *) 0 ;
51670 wxEdge arg4 ;
51671 int arg5 = (int) 0 ;
51672 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51673 void *argp1 = 0 ;
51674 int res1 = 0 ;
51675 int val2 ;
51676 int ecode2 = 0 ;
51677 void *argp3 = 0 ;
51678 int res3 = 0 ;
51679 int val4 ;
51680 int ecode4 = 0 ;
51681 int val5 ;
51682 int ecode5 = 0 ;
51683 int val6 ;
51684 int ecode6 = 0 ;
51685 PyObject * obj0 = 0 ;
51686 PyObject * obj1 = 0 ;
51687 PyObject * obj2 = 0 ;
51688 PyObject * obj3 = 0 ;
51689 PyObject * obj4 = 0 ;
51690 PyObject * obj5 = 0 ;
51691 char * kwnames[] = {
51692 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51693 };
51694
51695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51697 if (!SWIG_IsOK(res1)) {
51698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51699 }
51700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51701 ecode2 = SWIG_AsVal_int(obj1, &val2);
51702 if (!SWIG_IsOK(ecode2)) {
51703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51704 }
51705 arg2 = static_cast< wxRelationship >(val2);
51706 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51707 if (!SWIG_IsOK(res3)) {
51708 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51709 }
51710 arg3 = reinterpret_cast< wxWindow * >(argp3);
51711 ecode4 = SWIG_AsVal_int(obj3, &val4);
51712 if (!SWIG_IsOK(ecode4)) {
51713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51714 }
51715 arg4 = static_cast< wxEdge >(val4);
51716 if (obj4) {
51717 ecode5 = SWIG_AsVal_int(obj4, &val5);
51718 if (!SWIG_IsOK(ecode5)) {
51719 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51720 }
51721 arg5 = static_cast< int >(val5);
51722 }
51723 if (obj5) {
51724 ecode6 = SWIG_AsVal_int(obj5, &val6);
51725 if (!SWIG_IsOK(ecode6)) {
51726 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51727 }
51728 arg6 = static_cast< int >(val6);
51729 }
51730 {
51731 PyThreadState* __tstate = wxPyBeginAllowThreads();
51732 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51733 wxPyEndAllowThreads(__tstate);
51734 if (PyErr_Occurred()) SWIG_fail;
51735 }
51736 resultobj = SWIG_Py_Void();
51737 return resultobj;
51738 fail:
51739 return NULL;
51740 }
51741
51742
51743 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51744 PyObject *resultobj = 0;
51745 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51746 wxWindow *arg2 = (wxWindow *) 0 ;
51747 int arg3 = (int) 0 ;
51748 void *argp1 = 0 ;
51749 int res1 = 0 ;
51750 void *argp2 = 0 ;
51751 int res2 = 0 ;
51752 int val3 ;
51753 int ecode3 = 0 ;
51754 PyObject * obj0 = 0 ;
51755 PyObject * obj1 = 0 ;
51756 PyObject * obj2 = 0 ;
51757 char * kwnames[] = {
51758 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51759 };
51760
51761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51763 if (!SWIG_IsOK(res1)) {
51764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51765 }
51766 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51768 if (!SWIG_IsOK(res2)) {
51769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51770 }
51771 arg2 = reinterpret_cast< wxWindow * >(argp2);
51772 if (obj2) {
51773 ecode3 = SWIG_AsVal_int(obj2, &val3);
51774 if (!SWIG_IsOK(ecode3)) {
51775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51776 }
51777 arg3 = static_cast< int >(val3);
51778 }
51779 {
51780 PyThreadState* __tstate = wxPyBeginAllowThreads();
51781 (arg1)->LeftOf(arg2,arg3);
51782 wxPyEndAllowThreads(__tstate);
51783 if (PyErr_Occurred()) SWIG_fail;
51784 }
51785 resultobj = SWIG_Py_Void();
51786 return resultobj;
51787 fail:
51788 return NULL;
51789 }
51790
51791
51792 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51793 PyObject *resultobj = 0;
51794 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51795 wxWindow *arg2 = (wxWindow *) 0 ;
51796 int arg3 = (int) 0 ;
51797 void *argp1 = 0 ;
51798 int res1 = 0 ;
51799 void *argp2 = 0 ;
51800 int res2 = 0 ;
51801 int val3 ;
51802 int ecode3 = 0 ;
51803 PyObject * obj0 = 0 ;
51804 PyObject * obj1 = 0 ;
51805 PyObject * obj2 = 0 ;
51806 char * kwnames[] = {
51807 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51808 };
51809
51810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51814 }
51815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51817 if (!SWIG_IsOK(res2)) {
51818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51819 }
51820 arg2 = reinterpret_cast< wxWindow * >(argp2);
51821 if (obj2) {
51822 ecode3 = SWIG_AsVal_int(obj2, &val3);
51823 if (!SWIG_IsOK(ecode3)) {
51824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51825 }
51826 arg3 = static_cast< int >(val3);
51827 }
51828 {
51829 PyThreadState* __tstate = wxPyBeginAllowThreads();
51830 (arg1)->RightOf(arg2,arg3);
51831 wxPyEndAllowThreads(__tstate);
51832 if (PyErr_Occurred()) SWIG_fail;
51833 }
51834 resultobj = SWIG_Py_Void();
51835 return resultobj;
51836 fail:
51837 return NULL;
51838 }
51839
51840
51841 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51842 PyObject *resultobj = 0;
51843 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51844 wxWindow *arg2 = (wxWindow *) 0 ;
51845 int arg3 = (int) 0 ;
51846 void *argp1 = 0 ;
51847 int res1 = 0 ;
51848 void *argp2 = 0 ;
51849 int res2 = 0 ;
51850 int val3 ;
51851 int ecode3 = 0 ;
51852 PyObject * obj0 = 0 ;
51853 PyObject * obj1 = 0 ;
51854 PyObject * obj2 = 0 ;
51855 char * kwnames[] = {
51856 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51857 };
51858
51859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51861 if (!SWIG_IsOK(res1)) {
51862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51863 }
51864 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51866 if (!SWIG_IsOK(res2)) {
51867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51868 }
51869 arg2 = reinterpret_cast< wxWindow * >(argp2);
51870 if (obj2) {
51871 ecode3 = SWIG_AsVal_int(obj2, &val3);
51872 if (!SWIG_IsOK(ecode3)) {
51873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51874 }
51875 arg3 = static_cast< int >(val3);
51876 }
51877 {
51878 PyThreadState* __tstate = wxPyBeginAllowThreads();
51879 (arg1)->Above(arg2,arg3);
51880 wxPyEndAllowThreads(__tstate);
51881 if (PyErr_Occurred()) SWIG_fail;
51882 }
51883 resultobj = SWIG_Py_Void();
51884 return resultobj;
51885 fail:
51886 return NULL;
51887 }
51888
51889
51890 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51891 PyObject *resultobj = 0;
51892 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51893 wxWindow *arg2 = (wxWindow *) 0 ;
51894 int arg3 = (int) 0 ;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 void *argp2 = 0 ;
51898 int res2 = 0 ;
51899 int val3 ;
51900 int ecode3 = 0 ;
51901 PyObject * obj0 = 0 ;
51902 PyObject * obj1 = 0 ;
51903 PyObject * obj2 = 0 ;
51904 char * kwnames[] = {
51905 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51906 };
51907
51908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51910 if (!SWIG_IsOK(res1)) {
51911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51912 }
51913 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51915 if (!SWIG_IsOK(res2)) {
51916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51917 }
51918 arg2 = reinterpret_cast< wxWindow * >(argp2);
51919 if (obj2) {
51920 ecode3 = SWIG_AsVal_int(obj2, &val3);
51921 if (!SWIG_IsOK(ecode3)) {
51922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51923 }
51924 arg3 = static_cast< int >(val3);
51925 }
51926 {
51927 PyThreadState* __tstate = wxPyBeginAllowThreads();
51928 (arg1)->Below(arg2,arg3);
51929 wxPyEndAllowThreads(__tstate);
51930 if (PyErr_Occurred()) SWIG_fail;
51931 }
51932 resultobj = SWIG_Py_Void();
51933 return resultobj;
51934 fail:
51935 return NULL;
51936 }
51937
51938
51939 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51940 PyObject *resultobj = 0;
51941 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51942 wxWindow *arg2 = (wxWindow *) 0 ;
51943 wxEdge arg3 ;
51944 int arg4 = (int) 0 ;
51945 void *argp1 = 0 ;
51946 int res1 = 0 ;
51947 void *argp2 = 0 ;
51948 int res2 = 0 ;
51949 int val3 ;
51950 int ecode3 = 0 ;
51951 int val4 ;
51952 int ecode4 = 0 ;
51953 PyObject * obj0 = 0 ;
51954 PyObject * obj1 = 0 ;
51955 PyObject * obj2 = 0 ;
51956 PyObject * obj3 = 0 ;
51957 char * kwnames[] = {
51958 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51959 };
51960
51961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51963 if (!SWIG_IsOK(res1)) {
51964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51965 }
51966 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51968 if (!SWIG_IsOK(res2)) {
51969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51970 }
51971 arg2 = reinterpret_cast< wxWindow * >(argp2);
51972 ecode3 = SWIG_AsVal_int(obj2, &val3);
51973 if (!SWIG_IsOK(ecode3)) {
51974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51975 }
51976 arg3 = static_cast< wxEdge >(val3);
51977 if (obj3) {
51978 ecode4 = SWIG_AsVal_int(obj3, &val4);
51979 if (!SWIG_IsOK(ecode4)) {
51980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51981 }
51982 arg4 = static_cast< int >(val4);
51983 }
51984 {
51985 PyThreadState* __tstate = wxPyBeginAllowThreads();
51986 (arg1)->SameAs(arg2,arg3,arg4);
51987 wxPyEndAllowThreads(__tstate);
51988 if (PyErr_Occurred()) SWIG_fail;
51989 }
51990 resultobj = SWIG_Py_Void();
51991 return resultobj;
51992 fail:
51993 return NULL;
51994 }
51995
51996
51997 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51998 PyObject *resultobj = 0;
51999 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52000 wxWindow *arg2 = (wxWindow *) 0 ;
52001 wxEdge arg3 ;
52002 int arg4 ;
52003 void *argp1 = 0 ;
52004 int res1 = 0 ;
52005 void *argp2 = 0 ;
52006 int res2 = 0 ;
52007 int val3 ;
52008 int ecode3 = 0 ;
52009 int val4 ;
52010 int ecode4 = 0 ;
52011 PyObject * obj0 = 0 ;
52012 PyObject * obj1 = 0 ;
52013 PyObject * obj2 = 0 ;
52014 PyObject * obj3 = 0 ;
52015 char * kwnames[] = {
52016 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52017 };
52018
52019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52021 if (!SWIG_IsOK(res1)) {
52022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52023 }
52024 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52026 if (!SWIG_IsOK(res2)) {
52027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52028 }
52029 arg2 = reinterpret_cast< wxWindow * >(argp2);
52030 ecode3 = SWIG_AsVal_int(obj2, &val3);
52031 if (!SWIG_IsOK(ecode3)) {
52032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52033 }
52034 arg3 = static_cast< wxEdge >(val3);
52035 ecode4 = SWIG_AsVal_int(obj3, &val4);
52036 if (!SWIG_IsOK(ecode4)) {
52037 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52038 }
52039 arg4 = static_cast< int >(val4);
52040 {
52041 PyThreadState* __tstate = wxPyBeginAllowThreads();
52042 (arg1)->PercentOf(arg2,arg3,arg4);
52043 wxPyEndAllowThreads(__tstate);
52044 if (PyErr_Occurred()) SWIG_fail;
52045 }
52046 resultobj = SWIG_Py_Void();
52047 return resultobj;
52048 fail:
52049 return NULL;
52050 }
52051
52052
52053 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52054 PyObject *resultobj = 0;
52055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52056 int arg2 ;
52057 void *argp1 = 0 ;
52058 int res1 = 0 ;
52059 int val2 ;
52060 int ecode2 = 0 ;
52061 PyObject * obj0 = 0 ;
52062 PyObject * obj1 = 0 ;
52063 char * kwnames[] = {
52064 (char *) "self",(char *) "val", NULL
52065 };
52066
52067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52069 if (!SWIG_IsOK(res1)) {
52070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52071 }
52072 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52073 ecode2 = SWIG_AsVal_int(obj1, &val2);
52074 if (!SWIG_IsOK(ecode2)) {
52075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52076 }
52077 arg2 = static_cast< int >(val2);
52078 {
52079 PyThreadState* __tstate = wxPyBeginAllowThreads();
52080 (arg1)->Absolute(arg2);
52081 wxPyEndAllowThreads(__tstate);
52082 if (PyErr_Occurred()) SWIG_fail;
52083 }
52084 resultobj = SWIG_Py_Void();
52085 return resultobj;
52086 fail:
52087 return NULL;
52088 }
52089
52090
52091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52092 PyObject *resultobj = 0;
52093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52094 void *argp1 = 0 ;
52095 int res1 = 0 ;
52096 PyObject *swig_obj[1] ;
52097
52098 if (!args) SWIG_fail;
52099 swig_obj[0] = args;
52100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52101 if (!SWIG_IsOK(res1)) {
52102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52103 }
52104 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52105 {
52106 PyThreadState* __tstate = wxPyBeginAllowThreads();
52107 (arg1)->Unconstrained();
52108 wxPyEndAllowThreads(__tstate);
52109 if (PyErr_Occurred()) SWIG_fail;
52110 }
52111 resultobj = SWIG_Py_Void();
52112 return resultobj;
52113 fail:
52114 return NULL;
52115 }
52116
52117
52118 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52119 PyObject *resultobj = 0;
52120 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52121 void *argp1 = 0 ;
52122 int res1 = 0 ;
52123 PyObject *swig_obj[1] ;
52124
52125 if (!args) SWIG_fail;
52126 swig_obj[0] = args;
52127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52128 if (!SWIG_IsOK(res1)) {
52129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52130 }
52131 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52132 {
52133 PyThreadState* __tstate = wxPyBeginAllowThreads();
52134 (arg1)->AsIs();
52135 wxPyEndAllowThreads(__tstate);
52136 if (PyErr_Occurred()) SWIG_fail;
52137 }
52138 resultobj = SWIG_Py_Void();
52139 return resultobj;
52140 fail:
52141 return NULL;
52142 }
52143
52144
52145 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52146 PyObject *resultobj = 0;
52147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52148 wxWindow *result = 0 ;
52149 void *argp1 = 0 ;
52150 int res1 = 0 ;
52151 PyObject *swig_obj[1] ;
52152
52153 if (!args) SWIG_fail;
52154 swig_obj[0] = args;
52155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52156 if (!SWIG_IsOK(res1)) {
52157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52158 }
52159 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52160 {
52161 PyThreadState* __tstate = wxPyBeginAllowThreads();
52162 result = (wxWindow *)(arg1)->GetOtherWindow();
52163 wxPyEndAllowThreads(__tstate);
52164 if (PyErr_Occurred()) SWIG_fail;
52165 }
52166 {
52167 resultobj = wxPyMake_wxObject(result, 0);
52168 }
52169 return resultobj;
52170 fail:
52171 return NULL;
52172 }
52173
52174
52175 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52176 PyObject *resultobj = 0;
52177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52178 wxEdge result;
52179 void *argp1 = 0 ;
52180 int res1 = 0 ;
52181 PyObject *swig_obj[1] ;
52182
52183 if (!args) SWIG_fail;
52184 swig_obj[0] = args;
52185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52186 if (!SWIG_IsOK(res1)) {
52187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52188 }
52189 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52190 {
52191 PyThreadState* __tstate = wxPyBeginAllowThreads();
52192 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52193 wxPyEndAllowThreads(__tstate);
52194 if (PyErr_Occurred()) SWIG_fail;
52195 }
52196 resultobj = SWIG_From_int(static_cast< int >(result));
52197 return resultobj;
52198 fail:
52199 return NULL;
52200 }
52201
52202
52203 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52204 PyObject *resultobj = 0;
52205 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52206 wxEdge arg2 ;
52207 void *argp1 = 0 ;
52208 int res1 = 0 ;
52209 int val2 ;
52210 int ecode2 = 0 ;
52211 PyObject * obj0 = 0 ;
52212 PyObject * obj1 = 0 ;
52213 char * kwnames[] = {
52214 (char *) "self",(char *) "which", NULL
52215 };
52216
52217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52219 if (!SWIG_IsOK(res1)) {
52220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52221 }
52222 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52223 ecode2 = SWIG_AsVal_int(obj1, &val2);
52224 if (!SWIG_IsOK(ecode2)) {
52225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52226 }
52227 arg2 = static_cast< wxEdge >(val2);
52228 {
52229 PyThreadState* __tstate = wxPyBeginAllowThreads();
52230 (arg1)->SetEdge(arg2);
52231 wxPyEndAllowThreads(__tstate);
52232 if (PyErr_Occurred()) SWIG_fail;
52233 }
52234 resultobj = SWIG_Py_Void();
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52242 PyObject *resultobj = 0;
52243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52244 int arg2 ;
52245 void *argp1 = 0 ;
52246 int res1 = 0 ;
52247 int val2 ;
52248 int ecode2 = 0 ;
52249 PyObject * obj0 = 0 ;
52250 PyObject * obj1 = 0 ;
52251 char * kwnames[] = {
52252 (char *) "self",(char *) "v", NULL
52253 };
52254
52255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52257 if (!SWIG_IsOK(res1)) {
52258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52259 }
52260 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52261 ecode2 = SWIG_AsVal_int(obj1, &val2);
52262 if (!SWIG_IsOK(ecode2)) {
52263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52264 }
52265 arg2 = static_cast< int >(val2);
52266 {
52267 PyThreadState* __tstate = wxPyBeginAllowThreads();
52268 (arg1)->SetValue(arg2);
52269 wxPyEndAllowThreads(__tstate);
52270 if (PyErr_Occurred()) SWIG_fail;
52271 }
52272 resultobj = SWIG_Py_Void();
52273 return resultobj;
52274 fail:
52275 return NULL;
52276 }
52277
52278
52279 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52280 PyObject *resultobj = 0;
52281 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52282 int result;
52283 void *argp1 = 0 ;
52284 int res1 = 0 ;
52285 PyObject *swig_obj[1] ;
52286
52287 if (!args) SWIG_fail;
52288 swig_obj[0] = args;
52289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52290 if (!SWIG_IsOK(res1)) {
52291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52292 }
52293 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52294 {
52295 PyThreadState* __tstate = wxPyBeginAllowThreads();
52296 result = (int)(arg1)->GetMargin();
52297 wxPyEndAllowThreads(__tstate);
52298 if (PyErr_Occurred()) SWIG_fail;
52299 }
52300 resultobj = SWIG_From_int(static_cast< int >(result));
52301 return resultobj;
52302 fail:
52303 return NULL;
52304 }
52305
52306
52307 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52308 PyObject *resultobj = 0;
52309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52310 int arg2 ;
52311 void *argp1 = 0 ;
52312 int res1 = 0 ;
52313 int val2 ;
52314 int ecode2 = 0 ;
52315 PyObject * obj0 = 0 ;
52316 PyObject * obj1 = 0 ;
52317 char * kwnames[] = {
52318 (char *) "self",(char *) "m", NULL
52319 };
52320
52321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52323 if (!SWIG_IsOK(res1)) {
52324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52325 }
52326 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52327 ecode2 = SWIG_AsVal_int(obj1, &val2);
52328 if (!SWIG_IsOK(ecode2)) {
52329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52330 }
52331 arg2 = static_cast< int >(val2);
52332 {
52333 PyThreadState* __tstate = wxPyBeginAllowThreads();
52334 (arg1)->SetMargin(arg2);
52335 wxPyEndAllowThreads(__tstate);
52336 if (PyErr_Occurred()) SWIG_fail;
52337 }
52338 resultobj = SWIG_Py_Void();
52339 return resultobj;
52340 fail:
52341 return NULL;
52342 }
52343
52344
52345 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52346 PyObject *resultobj = 0;
52347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52348 int result;
52349 void *argp1 = 0 ;
52350 int res1 = 0 ;
52351 PyObject *swig_obj[1] ;
52352
52353 if (!args) SWIG_fail;
52354 swig_obj[0] = args;
52355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52356 if (!SWIG_IsOK(res1)) {
52357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52358 }
52359 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52360 {
52361 PyThreadState* __tstate = wxPyBeginAllowThreads();
52362 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52363 wxPyEndAllowThreads(__tstate);
52364 if (PyErr_Occurred()) SWIG_fail;
52365 }
52366 resultobj = SWIG_From_int(static_cast< int >(result));
52367 return resultobj;
52368 fail:
52369 return NULL;
52370 }
52371
52372
52373 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52374 PyObject *resultobj = 0;
52375 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52376 int result;
52377 void *argp1 = 0 ;
52378 int res1 = 0 ;
52379 PyObject *swig_obj[1] ;
52380
52381 if (!args) SWIG_fail;
52382 swig_obj[0] = args;
52383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52384 if (!SWIG_IsOK(res1)) {
52385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52386 }
52387 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52388 {
52389 PyThreadState* __tstate = wxPyBeginAllowThreads();
52390 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52391 wxPyEndAllowThreads(__tstate);
52392 if (PyErr_Occurred()) SWIG_fail;
52393 }
52394 resultobj = SWIG_From_int(static_cast< int >(result));
52395 return resultobj;
52396 fail:
52397 return NULL;
52398 }
52399
52400
52401 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52402 PyObject *resultobj = 0;
52403 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52404 int result;
52405 void *argp1 = 0 ;
52406 int res1 = 0 ;
52407 PyObject *swig_obj[1] ;
52408
52409 if (!args) SWIG_fail;
52410 swig_obj[0] = args;
52411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52412 if (!SWIG_IsOK(res1)) {
52413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52414 }
52415 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52416 {
52417 PyThreadState* __tstate = wxPyBeginAllowThreads();
52418 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52419 wxPyEndAllowThreads(__tstate);
52420 if (PyErr_Occurred()) SWIG_fail;
52421 }
52422 resultobj = SWIG_From_int(static_cast< int >(result));
52423 return resultobj;
52424 fail:
52425 return NULL;
52426 }
52427
52428
52429 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52430 PyObject *resultobj = 0;
52431 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52432 bool result;
52433 void *argp1 = 0 ;
52434 int res1 = 0 ;
52435 PyObject *swig_obj[1] ;
52436
52437 if (!args) SWIG_fail;
52438 swig_obj[0] = args;
52439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52440 if (!SWIG_IsOK(res1)) {
52441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52442 }
52443 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52444 {
52445 PyThreadState* __tstate = wxPyBeginAllowThreads();
52446 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52447 wxPyEndAllowThreads(__tstate);
52448 if (PyErr_Occurred()) SWIG_fail;
52449 }
52450 {
52451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52452 }
52453 return resultobj;
52454 fail:
52455 return NULL;
52456 }
52457
52458
52459 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52460 PyObject *resultobj = 0;
52461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52462 bool arg2 ;
52463 void *argp1 = 0 ;
52464 int res1 = 0 ;
52465 bool val2 ;
52466 int ecode2 = 0 ;
52467 PyObject * obj0 = 0 ;
52468 PyObject * obj1 = 0 ;
52469 char * kwnames[] = {
52470 (char *) "self",(char *) "d", NULL
52471 };
52472
52473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52475 if (!SWIG_IsOK(res1)) {
52476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52477 }
52478 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52479 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52480 if (!SWIG_IsOK(ecode2)) {
52481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52482 }
52483 arg2 = static_cast< bool >(val2);
52484 {
52485 PyThreadState* __tstate = wxPyBeginAllowThreads();
52486 (arg1)->SetDone(arg2);
52487 wxPyEndAllowThreads(__tstate);
52488 if (PyErr_Occurred()) SWIG_fail;
52489 }
52490 resultobj = SWIG_Py_Void();
52491 return resultobj;
52492 fail:
52493 return NULL;
52494 }
52495
52496
52497 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52498 PyObject *resultobj = 0;
52499 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52500 wxRelationship result;
52501 void *argp1 = 0 ;
52502 int res1 = 0 ;
52503 PyObject *swig_obj[1] ;
52504
52505 if (!args) SWIG_fail;
52506 swig_obj[0] = args;
52507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52508 if (!SWIG_IsOK(res1)) {
52509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52510 }
52511 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52512 {
52513 PyThreadState* __tstate = wxPyBeginAllowThreads();
52514 result = (wxRelationship)(arg1)->GetRelationship();
52515 wxPyEndAllowThreads(__tstate);
52516 if (PyErr_Occurred()) SWIG_fail;
52517 }
52518 resultobj = SWIG_From_int(static_cast< int >(result));
52519 return resultobj;
52520 fail:
52521 return NULL;
52522 }
52523
52524
52525 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52526 PyObject *resultobj = 0;
52527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52528 wxRelationship arg2 ;
52529 void *argp1 = 0 ;
52530 int res1 = 0 ;
52531 int val2 ;
52532 int ecode2 = 0 ;
52533 PyObject * obj0 = 0 ;
52534 PyObject * obj1 = 0 ;
52535 char * kwnames[] = {
52536 (char *) "self",(char *) "r", NULL
52537 };
52538
52539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52541 if (!SWIG_IsOK(res1)) {
52542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52543 }
52544 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52545 ecode2 = SWIG_AsVal_int(obj1, &val2);
52546 if (!SWIG_IsOK(ecode2)) {
52547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52548 }
52549 arg2 = static_cast< wxRelationship >(val2);
52550 {
52551 PyThreadState* __tstate = wxPyBeginAllowThreads();
52552 (arg1)->SetRelationship(arg2);
52553 wxPyEndAllowThreads(__tstate);
52554 if (PyErr_Occurred()) SWIG_fail;
52555 }
52556 resultobj = SWIG_Py_Void();
52557 return resultobj;
52558 fail:
52559 return NULL;
52560 }
52561
52562
52563 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52564 PyObject *resultobj = 0;
52565 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52566 wxWindow *arg2 = (wxWindow *) 0 ;
52567 bool result;
52568 void *argp1 = 0 ;
52569 int res1 = 0 ;
52570 void *argp2 = 0 ;
52571 int res2 = 0 ;
52572 PyObject * obj0 = 0 ;
52573 PyObject * obj1 = 0 ;
52574 char * kwnames[] = {
52575 (char *) "self",(char *) "otherW", NULL
52576 };
52577
52578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52580 if (!SWIG_IsOK(res1)) {
52581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52582 }
52583 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52585 if (!SWIG_IsOK(res2)) {
52586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52587 }
52588 arg2 = reinterpret_cast< wxWindow * >(argp2);
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 result = (bool)(arg1)->ResetIfWin(arg2);
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 {
52596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52597 }
52598 return resultobj;
52599 fail:
52600 return NULL;
52601 }
52602
52603
52604 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52605 PyObject *resultobj = 0;
52606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52607 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52608 wxWindow *arg3 = (wxWindow *) 0 ;
52609 bool result;
52610 void *argp1 = 0 ;
52611 int res1 = 0 ;
52612 void *argp2 = 0 ;
52613 int res2 = 0 ;
52614 void *argp3 = 0 ;
52615 int res3 = 0 ;
52616 PyObject * obj0 = 0 ;
52617 PyObject * obj1 = 0 ;
52618 PyObject * obj2 = 0 ;
52619 char * kwnames[] = {
52620 (char *) "self",(char *) "constraints",(char *) "win", NULL
52621 };
52622
52623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52625 if (!SWIG_IsOK(res1)) {
52626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52627 }
52628 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52630 if (!SWIG_IsOK(res2)) {
52631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52632 }
52633 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52634 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52635 if (!SWIG_IsOK(res3)) {
52636 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52637 }
52638 arg3 = reinterpret_cast< wxWindow * >(argp3);
52639 {
52640 PyThreadState* __tstate = wxPyBeginAllowThreads();
52641 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52642 wxPyEndAllowThreads(__tstate);
52643 if (PyErr_Occurred()) SWIG_fail;
52644 }
52645 {
52646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52647 }
52648 return resultobj;
52649 fail:
52650 return NULL;
52651 }
52652
52653
52654 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52655 PyObject *resultobj = 0;
52656 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52657 wxEdge arg2 ;
52658 wxWindow *arg3 = (wxWindow *) 0 ;
52659 wxWindow *arg4 = (wxWindow *) 0 ;
52660 int result;
52661 void *argp1 = 0 ;
52662 int res1 = 0 ;
52663 int val2 ;
52664 int ecode2 = 0 ;
52665 void *argp3 = 0 ;
52666 int res3 = 0 ;
52667 void *argp4 = 0 ;
52668 int res4 = 0 ;
52669 PyObject * obj0 = 0 ;
52670 PyObject * obj1 = 0 ;
52671 PyObject * obj2 = 0 ;
52672 PyObject * obj3 = 0 ;
52673 char * kwnames[] = {
52674 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52675 };
52676
52677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52679 if (!SWIG_IsOK(res1)) {
52680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52681 }
52682 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52683 ecode2 = SWIG_AsVal_int(obj1, &val2);
52684 if (!SWIG_IsOK(ecode2)) {
52685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52686 }
52687 arg2 = static_cast< wxEdge >(val2);
52688 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52689 if (!SWIG_IsOK(res3)) {
52690 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52691 }
52692 arg3 = reinterpret_cast< wxWindow * >(argp3);
52693 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52694 if (!SWIG_IsOK(res4)) {
52695 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52696 }
52697 arg4 = reinterpret_cast< wxWindow * >(argp4);
52698 {
52699 PyThreadState* __tstate = wxPyBeginAllowThreads();
52700 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52701 wxPyEndAllowThreads(__tstate);
52702 if (PyErr_Occurred()) SWIG_fail;
52703 }
52704 resultobj = SWIG_From_int(static_cast< int >(result));
52705 return resultobj;
52706 fail:
52707 return NULL;
52708 }
52709
52710
52711 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52712 PyObject *obj;
52713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52714 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52715 return SWIG_Py_Void();
52716 }
52717
52718 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52719 PyObject *resultobj = 0;
52720 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52721 wxIndividualLayoutConstraint *result = 0 ;
52722 void *argp1 = 0 ;
52723 int res1 = 0 ;
52724 PyObject *swig_obj[1] ;
52725
52726 if (!args) SWIG_fail;
52727 swig_obj[0] = args;
52728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52729 if (!SWIG_IsOK(res1)) {
52730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52731 }
52732 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52733 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52735 return resultobj;
52736 fail:
52737 return NULL;
52738 }
52739
52740
52741 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52742 PyObject *resultobj = 0;
52743 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52744 wxIndividualLayoutConstraint *result = 0 ;
52745 void *argp1 = 0 ;
52746 int res1 = 0 ;
52747 PyObject *swig_obj[1] ;
52748
52749 if (!args) SWIG_fail;
52750 swig_obj[0] = args;
52751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52752 if (!SWIG_IsOK(res1)) {
52753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52754 }
52755 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52756 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52758 return resultobj;
52759 fail:
52760 return NULL;
52761 }
52762
52763
52764 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52765 PyObject *resultobj = 0;
52766 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52767 wxIndividualLayoutConstraint *result = 0 ;
52768 void *argp1 = 0 ;
52769 int res1 = 0 ;
52770 PyObject *swig_obj[1] ;
52771
52772 if (!args) SWIG_fail;
52773 swig_obj[0] = args;
52774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52775 if (!SWIG_IsOK(res1)) {
52776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52777 }
52778 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52779 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52781 return resultobj;
52782 fail:
52783 return NULL;
52784 }
52785
52786
52787 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52788 PyObject *resultobj = 0;
52789 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52790 wxIndividualLayoutConstraint *result = 0 ;
52791 void *argp1 = 0 ;
52792 int res1 = 0 ;
52793 PyObject *swig_obj[1] ;
52794
52795 if (!args) SWIG_fail;
52796 swig_obj[0] = args;
52797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52798 if (!SWIG_IsOK(res1)) {
52799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52800 }
52801 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52802 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52804 return resultobj;
52805 fail:
52806 return NULL;
52807 }
52808
52809
52810 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52811 PyObject *resultobj = 0;
52812 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52813 wxIndividualLayoutConstraint *result = 0 ;
52814 void *argp1 = 0 ;
52815 int res1 = 0 ;
52816 PyObject *swig_obj[1] ;
52817
52818 if (!args) SWIG_fail;
52819 swig_obj[0] = args;
52820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52821 if (!SWIG_IsOK(res1)) {
52822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52823 }
52824 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52825 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52827 return resultobj;
52828 fail:
52829 return NULL;
52830 }
52831
52832
52833 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52834 PyObject *resultobj = 0;
52835 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52836 wxIndividualLayoutConstraint *result = 0 ;
52837 void *argp1 = 0 ;
52838 int res1 = 0 ;
52839 PyObject *swig_obj[1] ;
52840
52841 if (!args) SWIG_fail;
52842 swig_obj[0] = args;
52843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52844 if (!SWIG_IsOK(res1)) {
52845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52846 }
52847 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52848 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52850 return resultobj;
52851 fail:
52852 return NULL;
52853 }
52854
52855
52856 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52857 PyObject *resultobj = 0;
52858 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52859 wxIndividualLayoutConstraint *result = 0 ;
52860 void *argp1 = 0 ;
52861 int res1 = 0 ;
52862 PyObject *swig_obj[1] ;
52863
52864 if (!args) SWIG_fail;
52865 swig_obj[0] = args;
52866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52867 if (!SWIG_IsOK(res1)) {
52868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52869 }
52870 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52871 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52873 return resultobj;
52874 fail:
52875 return NULL;
52876 }
52877
52878
52879 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52880 PyObject *resultobj = 0;
52881 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52882 wxIndividualLayoutConstraint *result = 0 ;
52883 void *argp1 = 0 ;
52884 int res1 = 0 ;
52885 PyObject *swig_obj[1] ;
52886
52887 if (!args) SWIG_fail;
52888 swig_obj[0] = args;
52889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52890 if (!SWIG_IsOK(res1)) {
52891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52892 }
52893 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52894 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52896 return resultobj;
52897 fail:
52898 return NULL;
52899 }
52900
52901
52902 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52903 PyObject *resultobj = 0;
52904 wxLayoutConstraints *result = 0 ;
52905
52906 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52907 {
52908 PyThreadState* __tstate = wxPyBeginAllowThreads();
52909 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52910 wxPyEndAllowThreads(__tstate);
52911 if (PyErr_Occurred()) SWIG_fail;
52912 }
52913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52914 return resultobj;
52915 fail:
52916 return NULL;
52917 }
52918
52919
52920 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52921 PyObject *resultobj = 0;
52922 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52923 void *argp1 = 0 ;
52924 int res1 = 0 ;
52925 PyObject *swig_obj[1] ;
52926
52927 if (!args) SWIG_fail;
52928 swig_obj[0] = args;
52929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52930 if (!SWIG_IsOK(res1)) {
52931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52932 }
52933 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52934 {
52935 PyThreadState* __tstate = wxPyBeginAllowThreads();
52936 delete arg1;
52937
52938 wxPyEndAllowThreads(__tstate);
52939 if (PyErr_Occurred()) SWIG_fail;
52940 }
52941 resultobj = SWIG_Py_Void();
52942 return resultobj;
52943 fail:
52944 return NULL;
52945 }
52946
52947
52948 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52949 PyObject *resultobj = 0;
52950 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52951 wxWindow *arg2 = (wxWindow *) 0 ;
52952 int *arg3 = (int *) 0 ;
52953 bool result;
52954 void *argp1 = 0 ;
52955 int res1 = 0 ;
52956 void *argp2 = 0 ;
52957 int res2 = 0 ;
52958 int temp3 ;
52959 int res3 = SWIG_TMPOBJ ;
52960 PyObject * obj0 = 0 ;
52961 PyObject * obj1 = 0 ;
52962 char * kwnames[] = {
52963 (char *) "self",(char *) "win", NULL
52964 };
52965
52966 arg3 = &temp3;
52967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52969 if (!SWIG_IsOK(res1)) {
52970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52971 }
52972 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52973 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52974 if (!SWIG_IsOK(res2)) {
52975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52976 }
52977 arg2 = reinterpret_cast< wxWindow * >(argp2);
52978 {
52979 PyThreadState* __tstate = wxPyBeginAllowThreads();
52980 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52981 wxPyEndAllowThreads(__tstate);
52982 if (PyErr_Occurred()) SWIG_fail;
52983 }
52984 {
52985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52986 }
52987 if (SWIG_IsTmpObj(res3)) {
52988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52989 } else {
52990 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52992 }
52993 return resultobj;
52994 fail:
52995 return NULL;
52996 }
52997
52998
52999 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53000 PyObject *resultobj = 0;
53001 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53002 bool result;
53003 void *argp1 = 0 ;
53004 int res1 = 0 ;
53005 PyObject *swig_obj[1] ;
53006
53007 if (!args) SWIG_fail;
53008 swig_obj[0] = args;
53009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53010 if (!SWIG_IsOK(res1)) {
53011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53012 }
53013 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53014 {
53015 PyThreadState* __tstate = wxPyBeginAllowThreads();
53016 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53017 wxPyEndAllowThreads(__tstate);
53018 if (PyErr_Occurred()) SWIG_fail;
53019 }
53020 {
53021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53022 }
53023 return resultobj;
53024 fail:
53025 return NULL;
53026 }
53027
53028
53029 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53030 PyObject *obj;
53031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53032 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53033 return SWIG_Py_Void();
53034 }
53035
53036 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53037 return SWIG_Python_InitShadowInstance(args);
53038 }
53039
53040 static PyMethodDef SwigMethods[] = {
53041 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53042 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53043 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53044 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53045 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53046 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53047 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53048 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53049 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53051 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53062 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53063 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53064 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53066 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53067 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53068 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53069 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53070 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53071 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53072 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53074 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53080 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53081 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53082 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53083 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53084 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53085 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53086 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53088 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53096 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53097 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53098 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53103 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53104 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53106 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53108 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53110 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53112 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53114 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53116 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53117 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53119 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53121 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53122 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53123 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53124 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53144 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53145 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53146 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53147 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53148 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53149 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53150 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53151 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53153 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53154 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53155 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53160 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53161 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53162 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53163 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53170 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53177 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53178 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53179 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53180 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53182 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53183 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53186 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53187 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53188 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53189 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53194 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53195 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53196 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53197 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53198 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53199 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53202 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53203 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53204 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53206 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53207 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53209 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53210 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53211 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53212 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53213 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53214 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53215 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53216 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53217 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53218 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53219 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53224 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53230 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53231 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53232 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53233 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53235 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53238 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53240 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53243 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53244 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53245 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53248 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53249 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53250 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53254 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53255 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53256 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53260 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53265 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53266 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53267 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53268 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53269 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53270 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53271 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53278 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53279 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53281 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53282 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53283 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53289 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53290 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53292 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53293 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53294 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53295 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53296 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53297 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53298 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53299 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53301 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53302 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53303 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53304 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53305 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53306 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53307 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53308 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53310 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53319 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53331 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53332 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53347 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53348 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53349 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53350 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53353 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53355 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53357 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53359 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53361 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53364 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53365 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53366 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53367 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53369 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53386 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53387 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53393 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53394 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53396 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53397 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53398 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53399 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53400 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53401 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53402 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53403 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53404 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53405 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53406 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53407 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53408 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53409 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53410 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53411 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53412 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53413 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53414 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53415 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53417 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53418 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53420 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53421 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53423 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53424 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53426 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53427 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53428 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53430 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53431 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53432 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53433 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53436 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53440 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53444 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53445 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53446 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53447 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53449 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53450 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53452 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53454 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53456 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53458 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53459 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53460 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53462 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53463 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53465 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53466 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53467 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53469 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53470 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53471 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53473 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53475 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53476 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53477 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53479 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53481 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53482 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53484 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53485 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53486 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53488 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53489 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53490 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53491 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53492 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53494 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53495 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53498 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53499 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53501 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53502 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53505 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53506 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53508 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53514 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53515 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53516 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53517 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53518 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53519 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53520 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53521 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53522 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53523 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53524 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53525 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53526 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53527 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53528 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53529 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53530 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53531 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53532 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53533 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53534 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53535 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53536 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53537 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53539 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53540 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53541 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53542 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53543 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53544 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53545 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53546 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53547 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53548 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53549 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53550 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53551 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53552 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53553 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53554 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53555 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53556 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53557 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53558 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53559 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53560 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53561 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53562 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53563 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53564 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53565 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53566 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53567 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53568 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53569 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53570 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53572 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53573 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53575 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53576 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53577 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53578 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53580 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53581 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53582 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53583 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53584 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53585 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53586 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53587 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53588 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53590 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53591 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53592 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53593 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53594 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53595 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53596 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53597 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53598 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53599 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53600 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53601 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53602 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53603 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53604 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53605 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53606 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53607 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53608 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53609 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53610 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53611 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53612 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53613 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53614 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53615 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53616 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53617 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53619 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53620 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53623 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53624 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53625 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53626 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53627 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53628 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53630 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53631 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53634 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53635 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53637 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53638 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53640 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53641 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53643 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53644 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53645 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53647 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53649 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53650 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53652 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53653 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53654 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53656 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53657 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53658 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53660 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53661 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53663 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53664 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53665 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53666 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53667 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53670 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53672 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53674 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53675 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53676 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53679 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53680 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53681 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53683 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53684 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53685 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53687 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53688 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53689 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53690 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53691 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53692 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53694 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53695 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53696 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53697 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53698 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53699 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53700 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53701 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53707 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53709 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53711 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53712 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53713 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53714 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53715 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53716 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53718 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53719 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53720 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53722 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53723 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53724 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53725 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53726 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53729 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53730 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53731 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53734 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53735 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53736 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53737 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53738 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53740 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53742 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53745 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53747 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53748 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53750 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53751 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53752 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53754 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53755 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53756 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53758 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53760 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53761 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53762 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53764 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53766 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53768 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53769 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53771 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53772 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53774 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53776 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53777 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53778 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53780 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53782 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53783 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53784 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53786 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53788 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53789 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53790 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53791 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53793 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53795 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53797 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53799 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53800 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53802 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53803 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53804 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53805 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53806 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53807 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53808 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53809 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53811 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53813 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53815 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53817 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53819 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53821 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53822 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53823 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53824 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53825 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53826 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53832 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53833 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53834 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53835 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53836 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53837 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53838 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53839 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53841 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53843 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53844 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53846 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53847 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53848 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53849 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53851 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53852 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53853 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53854 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53856 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53857 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53859 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53860 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53861 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53863 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53865 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53866 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53867 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53868 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53869 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53871 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53872 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53873 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53874 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53876 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53877 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53878 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53879 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53880 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53881 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53882 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53883 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53884 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53885 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53887 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53890 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53891 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53892 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53894 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53896 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53898 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53900 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53901 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53911 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53912 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53916 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53917 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53918 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53919 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53920 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53921 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53922 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53923 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53924 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53925 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53926 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53927 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53928 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53929 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53930 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53932 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53933 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53936 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53937 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53942 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53943 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53946 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53947 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53948 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53949 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53952 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53953 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53954 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53956 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53958 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53959 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53960 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53962 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53964 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53966 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53969 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53970 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53971 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53972 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53973 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53974 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53978 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53979 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53980 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53981 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53988 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53994 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53995 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53996 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53997 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53998 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54000 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54010 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54011 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54012 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54013 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54016 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54017 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54018 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54019 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54021 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54022 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54026 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54032 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54033 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54034 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54035 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54037 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54038 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54040 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54043 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54045 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54046 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54047 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54056 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54060 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54061 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54063 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54073 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54074 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54075 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54076 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54080 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54083 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54085 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54088 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54090 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54091 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54094 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54096 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54097 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54098 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54099 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54101 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54102 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54107 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54108 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54109 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54111 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54112 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54113 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54115 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54117 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54118 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54119 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54121 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54122 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54125 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54133 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54140 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54148 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54151 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54152 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54165 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54167 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54169 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54170 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54172 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54174 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54175 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54177 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54178 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54179 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54183 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54202 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54203 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54205 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54206 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54208 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54209 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54210 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54212 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54213 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54216 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54217 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54219 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54220 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54222 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54225 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54226 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54228 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54230 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54232 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54233 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54235 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54236 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54239 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54241 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54243 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54245 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54248 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54250 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54251 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54252 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54254 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54255 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54256 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54258 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54260 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54261 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54263 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54265 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54266 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54270 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54274 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54275 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54277 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54281 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54283 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54285 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54286 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54287 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54288 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54292 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54293 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54294 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54295 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54297 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54298 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54303 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54304 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54305 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54306 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54307 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54309 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54311 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54313 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54314 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54316 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54318 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54321 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54322 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54323 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54325 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54326 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54327 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54341 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54342 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54343 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54344 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54345 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54346 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54352 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54353 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54357 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54358 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54360 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54361 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54363 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54365 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54366 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54368 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54369 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54376 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54377 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54378 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54379 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54380 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54381 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54388 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54390 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54391 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54392 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54393 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54394 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54395 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54397 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54401 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54402 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54403 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54404 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54405 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54406 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54407 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54409 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54410 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54411 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54417 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54418 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54419 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54421 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54422 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54423 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54429 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54430 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54431 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54432 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54433 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54437 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54438 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54443 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54444 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54446 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54447 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54452 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54454 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54455 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54456 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54457 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54458 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54463 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54464 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54473 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54474 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54475 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54476 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54479 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54481 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54482 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54483 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54484 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54486 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54491 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54492 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54493 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54494 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54495 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54496 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54497 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54498 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54499 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54500 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54501 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54503 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54504 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54505 { NULL, NULL, 0, NULL }
54506 };
54507
54508
54509 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54510
54511 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54512 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54513 }
54514 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54515 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54516 }
54517 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54518 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54519 }
54520 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54521 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54522 }
54523 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54524 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54525 }
54526 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54527 return (void *)((wxSizer *) ((wxGridSizer *) x));
54528 }
54529 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54530 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54531 }
54532 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54533 return (void *)((wxSizer *) ((wxPySizer *) x));
54534 }
54535 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54536 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54537 }
54538 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54539 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54540 }
54541 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54542 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54543 }
54544 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54545 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54546 }
54547 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54548 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54549 }
54550 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54551 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54552 }
54553 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54554 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54555 }
54556 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54557 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54558 }
54559 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54560 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54561 }
54562 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54563 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54564 }
54565 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54566 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54567 }
54568 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54569 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54570 }
54571 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54572 return (void *)((wxEvent *) ((wxPyEvent *) x));
54573 }
54574 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54575 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54576 }
54577 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54578 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54579 }
54580 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54581 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54582 }
54583 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54584 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54585 }
54586 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54587 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54588 }
54589 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54590 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54591 }
54592 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54593 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54594 }
54595 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54596 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54597 }
54598 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54599 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54600 }
54601 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54602 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54603 }
54604 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54605 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54606 }
54607 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54608 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54609 }
54610 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54611 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54612 }
54613 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54614 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54615 }
54616 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54617 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54618 }
54619 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54620 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54621 }
54622 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54623 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54624 }
54625 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54626 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54627 }
54628 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54629 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54630 }
54631 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54632 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54633 }
54634 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54635 return (void *)((wxEvent *) ((wxShowEvent *) x));
54636 }
54637 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54638 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54639 }
54640 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54641 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54642 }
54643 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54644 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54645 }
54646 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54647 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54648 }
54649 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54650 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54651 }
54652 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54653 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54654 }
54655 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54656 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54657 }
54658 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54659 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54660 }
54661 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54662 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54663 }
54664 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54665 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54666 }
54667 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54668 return (void *)((wxControl *) ((wxControlWithItems *) x));
54669 }
54670 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54671 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54672 }
54673 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54674 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54675 }
54676 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54677 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54678 }
54679 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54680 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54681 }
54682 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54683 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54684 }
54685 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54686 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54687 }
54688 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54689 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54690 }
54691 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54692 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54693 }
54694 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54695 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54696 }
54697 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54698 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54699 }
54700 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54701 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54702 }
54703 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54704 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54705 }
54706 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54707 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54708 }
54709 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54710 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54711 }
54712 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54713 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54714 }
54715 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54716 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54717 }
54718 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54719 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54720 }
54721 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54722 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54723 }
54724 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54725 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54726 }
54727 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54728 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54729 }
54730 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54731 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54732 }
54733 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54734 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54735 }
54736 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54737 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54738 }
54739 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54740 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54741 }
54742 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54743 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54744 }
54745 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54746 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54747 }
54748 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54749 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54750 }
54751 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54752 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54753 }
54754 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54755 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54756 }
54757 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54758 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54759 }
54760 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54761 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54762 }
54763 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54764 return (void *)((wxObject *) ((wxSizerItem *) x));
54765 }
54766 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54767 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54768 }
54769 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54770 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54771 }
54772 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54773 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54774 }
54775 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54776 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54777 }
54778 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54779 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54780 }
54781 static void *_p_wxSizerTo_p_wxObject(void *x) {
54782 return (void *)((wxObject *) ((wxSizer *) x));
54783 }
54784 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54785 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54786 }
54787 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54788 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54789 }
54790 static void *_p_wxEventTo_p_wxObject(void *x) {
54791 return (void *)((wxObject *) ((wxEvent *) x));
54792 }
54793 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54794 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54795 }
54796 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54797 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54798 }
54799 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54800 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54801 }
54802 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54803 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54804 }
54805 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54806 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54807 }
54808 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54809 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54810 }
54811 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54812 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54813 }
54814 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54815 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54816 }
54817 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54818 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54819 }
54820 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54821 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54822 }
54823 static void *_p_wxControlTo_p_wxObject(void *x) {
54824 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54825 }
54826 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54827 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54828 }
54829 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54830 return (void *)((wxObject *) ((wxFSFile *) x));
54831 }
54832 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54833 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54834 }
54835 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54836 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54837 }
54838 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54839 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54840 }
54841 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54842 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54843 }
54844 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54845 return (void *)((wxObject *) ((wxMenuItem *) x));
54846 }
54847 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54848 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54849 }
54850 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54851 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54852 }
54853 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54854 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54855 }
54856 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54857 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54858 }
54859 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54860 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54861 }
54862 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54863 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54864 }
54865 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54866 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54867 }
54868 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54869 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54870 }
54871 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54872 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54873 }
54874 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54875 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54876 }
54877 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54878 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54879 }
54880 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54881 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54882 }
54883 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54884 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54885 }
54886 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54887 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54888 }
54889 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54890 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54891 }
54892 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54893 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54894 }
54895 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54896 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54897 }
54898 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54899 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54900 }
54901 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54902 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54903 }
54904 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54905 return (void *)((wxObject *) ((wxImageHandler *) x));
54906 }
54907 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54908 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54909 }
54910 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54911 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54912 }
54913 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54914 return (void *)((wxObject *) ((wxEvtHandler *) x));
54915 }
54916 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54917 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54918 }
54919 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54920 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54921 }
54922 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54923 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54924 }
54925 static void *_p_wxImageTo_p_wxObject(void *x) {
54926 return (void *)((wxObject *) ((wxImage *) x));
54927 }
54928 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54929 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54930 }
54931 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54932 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54933 }
54934 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54935 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54936 }
54937 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54938 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54939 }
54940 static void *_p_wxWindowTo_p_wxObject(void *x) {
54941 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54942 }
54943 static void *_p_wxMenuTo_p_wxObject(void *x) {
54944 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54945 }
54946 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54947 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54948 }
54949 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54950 return (void *)((wxObject *) ((wxFileSystem *) x));
54951 }
54952 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54953 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54954 }
54955 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54956 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54957 }
54958 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54959 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54960 }
54961 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54962 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54963 }
54964 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54965 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54966 }
54967 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54968 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54969 }
54970 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54971 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54972 }
54973 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54974 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54975 }
54976 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54977 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54978 }
54979 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54980 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54981 }
54982 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54983 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54984 }
54985 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54986 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54987 }
54988 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54989 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54990 }
54991 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54992 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54993 }
54994 static void *_p_wxControlTo_p_wxWindow(void *x) {
54995 return (void *)((wxWindow *) ((wxControl *) x));
54996 }
54997 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54998 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54999 }
55000 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55001 return (void *)((wxWindow *) ((wxMenuBar *) x));
55002 }
55003 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55004 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55005 }
55006 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55007 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55008 }
55009 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55010 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55011 }
55012 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55013 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55014 }
55015 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55016 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55017 }
55018 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55019 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55020 }
55021 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55022 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55023 }
55024 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55025 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55026 }
55027 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55028 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55029 }
55030 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55031 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55032 }
55033 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55034 return (void *)((wxValidator *) ((wxPyValidator *) x));
55035 }
55036 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55037 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55038 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};
55039 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55040 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55041 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55042 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55043 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55044 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55045 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55046 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55047 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55048 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55049 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55050 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55051 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55052 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55053 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55054 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55055 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55056 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55057 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55058 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55059 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55060 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55061 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55062 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55064 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55065 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55168
55169 static swig_type_info *swig_type_initial[] = {
55170 &_swigt__p_buffer,
55171 &_swigt__p_char,
55172 &_swigt__p_form_ops_t,
55173 &_swigt__p_int,
55174 &_swigt__p_long,
55175 &_swigt__p_unsigned_char,
55176 &_swigt__p_unsigned_int,
55177 &_swigt__p_unsigned_long,
55178 &_swigt__p_wxANIHandler,
55179 &_swigt__p_wxAcceleratorEntry,
55180 &_swigt__p_wxAcceleratorTable,
55181 &_swigt__p_wxActivateEvent,
55182 &_swigt__p_wxAppTraits,
55183 &_swigt__p_wxArrayString,
55184 &_swigt__p_wxBMPHandler,
55185 &_swigt__p_wxBitmap,
55186 &_swigt__p_wxBoxSizer,
55187 &_swigt__p_wxButton,
55188 &_swigt__p_wxCURHandler,
55189 &_swigt__p_wxCaret,
55190 &_swigt__p_wxChildFocusEvent,
55191 &_swigt__p_wxClipboardTextEvent,
55192 &_swigt__p_wxCloseEvent,
55193 &_swigt__p_wxColour,
55194 &_swigt__p_wxCommandEvent,
55195 &_swigt__p_wxContextMenuEvent,
55196 &_swigt__p_wxControl,
55197 &_swigt__p_wxControlWithItems,
55198 &_swigt__p_wxCursor,
55199 &_swigt__p_wxDC,
55200 &_swigt__p_wxDateEvent,
55201 &_swigt__p_wxDateTime,
55202 &_swigt__p_wxDisplayChangedEvent,
55203 &_swigt__p_wxDropFilesEvent,
55204 &_swigt__p_wxDuplexMode,
55205 &_swigt__p_wxEraseEvent,
55206 &_swigt__p_wxEvent,
55207 &_swigt__p_wxEventLoop,
55208 &_swigt__p_wxEventLoopActivator,
55209 &_swigt__p_wxEvtHandler,
55210 &_swigt__p_wxFSFile,
55211 &_swigt__p_wxFileSystem,
55212 &_swigt__p_wxFileSystemHandler,
55213 &_swigt__p_wxFlexGridSizer,
55214 &_swigt__p_wxFocusEvent,
55215 &_swigt__p_wxFont,
55216 &_swigt__p_wxFrame,
55217 &_swigt__p_wxGBPosition,
55218 &_swigt__p_wxGBSizerItem,
55219 &_swigt__p_wxGBSpan,
55220 &_swigt__p_wxGIFHandler,
55221 &_swigt__p_wxGridBagSizer,
55222 &_swigt__p_wxGridSizer,
55223 &_swigt__p_wxHelpEvent__Origin,
55224 &_swigt__p_wxICOHandler,
55225 &_swigt__p_wxIconizeEvent,
55226 &_swigt__p_wxIdleEvent,
55227 &_swigt__p_wxImage,
55228 &_swigt__p_wxImageHandler,
55229 &_swigt__p_wxImageHistogram,
55230 &_swigt__p_wxImage_HSVValue,
55231 &_swigt__p_wxImage_RGBValue,
55232 &_swigt__p_wxIndividualLayoutConstraint,
55233 &_swigt__p_wxInitDialogEvent,
55234 &_swigt__p_wxInputStream,
55235 &_swigt__p_wxInternetFSHandler,
55236 &_swigt__p_wxItemContainer,
55237 &_swigt__p_wxJPEGHandler,
55238 &_swigt__p_wxKeyEvent,
55239 &_swigt__p_wxLayoutConstraints,
55240 &_swigt__p_wxMaximizeEvent,
55241 &_swigt__p_wxMemoryFSHandler,
55242 &_swigt__p_wxMenu,
55243 &_swigt__p_wxMenuBar,
55244 &_swigt__p_wxMenuBarBase,
55245 &_swigt__p_wxMenuEvent,
55246 &_swigt__p_wxMenuItem,
55247 &_swigt__p_wxMouseCaptureChangedEvent,
55248 &_swigt__p_wxMouseCaptureLostEvent,
55249 &_swigt__p_wxMouseEvent,
55250 &_swigt__p_wxMoveEvent,
55251 &_swigt__p_wxNavigationKeyEvent,
55252 &_swigt__p_wxNcPaintEvent,
55253 &_swigt__p_wxNotifyEvent,
55254 &_swigt__p_wxObject,
55255 &_swigt__p_wxOutputStream,
55256 &_swigt__p_wxPCXHandler,
55257 &_swigt__p_wxPNGHandler,
55258 &_swigt__p_wxPNMHandler,
55259 &_swigt__p_wxPaintEvent,
55260 &_swigt__p_wxPaletteChangedEvent,
55261 &_swigt__p_wxPaperSize,
55262 &_swigt__p_wxPoint,
55263 &_swigt__p_wxPoint2D,
55264 &_swigt__p_wxPropagateOnce,
55265 &_swigt__p_wxPropagationDisabler,
55266 &_swigt__p_wxPyApp,
55267 &_swigt__p_wxPyCommandEvent,
55268 &_swigt__p_wxPyDropTarget,
55269 &_swigt__p_wxPyEvent,
55270 &_swigt__p_wxPyFileSystemHandler,
55271 &_swigt__p_wxPyImageHandler,
55272 &_swigt__p_wxPyInputStream,
55273 &_swigt__p_wxPySizer,
55274 &_swigt__p_wxPyValidator,
55275 &_swigt__p_wxQuantize,
55276 &_swigt__p_wxQueryNewPaletteEvent,
55277 &_swigt__p_wxRealPoint,
55278 &_swigt__p_wxRect,
55279 &_swigt__p_wxRegion,
55280 &_swigt__p_wxScrollEvent,
55281 &_swigt__p_wxScrollWinEvent,
55282 &_swigt__p_wxSetCursorEvent,
55283 &_swigt__p_wxShowEvent,
55284 &_swigt__p_wxSize,
55285 &_swigt__p_wxSizeEvent,
55286 &_swigt__p_wxSizer,
55287 &_swigt__p_wxSizerItem,
55288 &_swigt__p_wxStaticBox,
55289 &_swigt__p_wxStaticBoxSizer,
55290 &_swigt__p_wxStdDialogButtonSizer,
55291 &_swigt__p_wxSysColourChangedEvent,
55292 &_swigt__p_wxTIFFHandler,
55293 &_swigt__p_wxToolTip,
55294 &_swigt__p_wxUpdateUIEvent,
55295 &_swigt__p_wxValidator,
55296 &_swigt__p_wxVisualAttributes,
55297 &_swigt__p_wxWindow,
55298 &_swigt__p_wxWindowCreateEvent,
55299 &_swigt__p_wxWindowDestroyEvent,
55300 &_swigt__p_wxXPMHandler,
55301 &_swigt__p_wxZipFSHandler,
55302 };
55303
55304 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55305 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55306 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55307 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55308 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55309 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55310 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55311 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55312 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55313 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55314 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55315 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55316 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55317 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55318 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}};
55319 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55320 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}};
55321 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55322 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}};
55323 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55324 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55325 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55326 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55327 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55328 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}};
55329 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55330 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}};
55331 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55332 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55333 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55335 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55336 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55337 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55338 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55339 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55340 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55341 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55343 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}};
55344 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55345 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55346 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}};
55347 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}};
55348 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55354 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55355 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55356 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}};
55357 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55358 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}};
55359 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55361 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55362 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}};
55363 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55364 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55365 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55366 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55367 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55369 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55370 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}};
55371 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55372 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55373 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55374 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55375 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55376 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55379 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55380 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55384 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55387 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55388 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_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_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55420 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}};
55421 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}};
55422 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55429 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}};
55430 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55431 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}};
55432 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55436
55437 static swig_cast_info *swig_cast_initial[] = {
55438 _swigc__p_buffer,
55439 _swigc__p_char,
55440 _swigc__p_form_ops_t,
55441 _swigc__p_int,
55442 _swigc__p_long,
55443 _swigc__p_unsigned_char,
55444 _swigc__p_unsigned_int,
55445 _swigc__p_unsigned_long,
55446 _swigc__p_wxANIHandler,
55447 _swigc__p_wxAcceleratorEntry,
55448 _swigc__p_wxAcceleratorTable,
55449 _swigc__p_wxActivateEvent,
55450 _swigc__p_wxAppTraits,
55451 _swigc__p_wxArrayString,
55452 _swigc__p_wxBMPHandler,
55453 _swigc__p_wxBitmap,
55454 _swigc__p_wxBoxSizer,
55455 _swigc__p_wxButton,
55456 _swigc__p_wxCURHandler,
55457 _swigc__p_wxCaret,
55458 _swigc__p_wxChildFocusEvent,
55459 _swigc__p_wxClipboardTextEvent,
55460 _swigc__p_wxCloseEvent,
55461 _swigc__p_wxColour,
55462 _swigc__p_wxCommandEvent,
55463 _swigc__p_wxContextMenuEvent,
55464 _swigc__p_wxControl,
55465 _swigc__p_wxControlWithItems,
55466 _swigc__p_wxCursor,
55467 _swigc__p_wxDC,
55468 _swigc__p_wxDateEvent,
55469 _swigc__p_wxDateTime,
55470 _swigc__p_wxDisplayChangedEvent,
55471 _swigc__p_wxDropFilesEvent,
55472 _swigc__p_wxDuplexMode,
55473 _swigc__p_wxEraseEvent,
55474 _swigc__p_wxEvent,
55475 _swigc__p_wxEventLoop,
55476 _swigc__p_wxEventLoopActivator,
55477 _swigc__p_wxEvtHandler,
55478 _swigc__p_wxFSFile,
55479 _swigc__p_wxFileSystem,
55480 _swigc__p_wxFileSystemHandler,
55481 _swigc__p_wxFlexGridSizer,
55482 _swigc__p_wxFocusEvent,
55483 _swigc__p_wxFont,
55484 _swigc__p_wxFrame,
55485 _swigc__p_wxGBPosition,
55486 _swigc__p_wxGBSizerItem,
55487 _swigc__p_wxGBSpan,
55488 _swigc__p_wxGIFHandler,
55489 _swigc__p_wxGridBagSizer,
55490 _swigc__p_wxGridSizer,
55491 _swigc__p_wxHelpEvent__Origin,
55492 _swigc__p_wxICOHandler,
55493 _swigc__p_wxIconizeEvent,
55494 _swigc__p_wxIdleEvent,
55495 _swigc__p_wxImage,
55496 _swigc__p_wxImageHandler,
55497 _swigc__p_wxImageHistogram,
55498 _swigc__p_wxImage_HSVValue,
55499 _swigc__p_wxImage_RGBValue,
55500 _swigc__p_wxIndividualLayoutConstraint,
55501 _swigc__p_wxInitDialogEvent,
55502 _swigc__p_wxInputStream,
55503 _swigc__p_wxInternetFSHandler,
55504 _swigc__p_wxItemContainer,
55505 _swigc__p_wxJPEGHandler,
55506 _swigc__p_wxKeyEvent,
55507 _swigc__p_wxLayoutConstraints,
55508 _swigc__p_wxMaximizeEvent,
55509 _swigc__p_wxMemoryFSHandler,
55510 _swigc__p_wxMenu,
55511 _swigc__p_wxMenuBar,
55512 _swigc__p_wxMenuBarBase,
55513 _swigc__p_wxMenuEvent,
55514 _swigc__p_wxMenuItem,
55515 _swigc__p_wxMouseCaptureChangedEvent,
55516 _swigc__p_wxMouseCaptureLostEvent,
55517 _swigc__p_wxMouseEvent,
55518 _swigc__p_wxMoveEvent,
55519 _swigc__p_wxNavigationKeyEvent,
55520 _swigc__p_wxNcPaintEvent,
55521 _swigc__p_wxNotifyEvent,
55522 _swigc__p_wxObject,
55523 _swigc__p_wxOutputStream,
55524 _swigc__p_wxPCXHandler,
55525 _swigc__p_wxPNGHandler,
55526 _swigc__p_wxPNMHandler,
55527 _swigc__p_wxPaintEvent,
55528 _swigc__p_wxPaletteChangedEvent,
55529 _swigc__p_wxPaperSize,
55530 _swigc__p_wxPoint,
55531 _swigc__p_wxPoint2D,
55532 _swigc__p_wxPropagateOnce,
55533 _swigc__p_wxPropagationDisabler,
55534 _swigc__p_wxPyApp,
55535 _swigc__p_wxPyCommandEvent,
55536 _swigc__p_wxPyDropTarget,
55537 _swigc__p_wxPyEvent,
55538 _swigc__p_wxPyFileSystemHandler,
55539 _swigc__p_wxPyImageHandler,
55540 _swigc__p_wxPyInputStream,
55541 _swigc__p_wxPySizer,
55542 _swigc__p_wxPyValidator,
55543 _swigc__p_wxQuantize,
55544 _swigc__p_wxQueryNewPaletteEvent,
55545 _swigc__p_wxRealPoint,
55546 _swigc__p_wxRect,
55547 _swigc__p_wxRegion,
55548 _swigc__p_wxScrollEvent,
55549 _swigc__p_wxScrollWinEvent,
55550 _swigc__p_wxSetCursorEvent,
55551 _swigc__p_wxShowEvent,
55552 _swigc__p_wxSize,
55553 _swigc__p_wxSizeEvent,
55554 _swigc__p_wxSizer,
55555 _swigc__p_wxSizerItem,
55556 _swigc__p_wxStaticBox,
55557 _swigc__p_wxStaticBoxSizer,
55558 _swigc__p_wxStdDialogButtonSizer,
55559 _swigc__p_wxSysColourChangedEvent,
55560 _swigc__p_wxTIFFHandler,
55561 _swigc__p_wxToolTip,
55562 _swigc__p_wxUpdateUIEvent,
55563 _swigc__p_wxValidator,
55564 _swigc__p_wxVisualAttributes,
55565 _swigc__p_wxWindow,
55566 _swigc__p_wxWindowCreateEvent,
55567 _swigc__p_wxWindowDestroyEvent,
55568 _swigc__p_wxXPMHandler,
55569 _swigc__p_wxZipFSHandler,
55570 };
55571
55572
55573 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55574
55575 static swig_const_info swig_const_table[] = {
55576 {0, 0, 0, 0.0, 0, 0}};
55577
55578 #ifdef __cplusplus
55579 }
55580 #endif
55581 /* -----------------------------------------------------------------------------
55582 * Type initialization:
55583 * This problem is tough by the requirement that no dynamic
55584 * memory is used. Also, since swig_type_info structures store pointers to
55585 * swig_cast_info structures and swig_cast_info structures store pointers back
55586 * to swig_type_info structures, we need some lookup code at initialization.
55587 * The idea is that swig generates all the structures that are needed.
55588 * The runtime then collects these partially filled structures.
55589 * The SWIG_InitializeModule function takes these initial arrays out of
55590 * swig_module, and does all the lookup, filling in the swig_module.types
55591 * array with the correct data and linking the correct swig_cast_info
55592 * structures together.
55593 *
55594 * The generated swig_type_info structures are assigned staticly to an initial
55595 * array. We just loop though that array, and handle each type individually.
55596 * First we lookup if this type has been already loaded, and if so, use the
55597 * loaded structure instead of the generated one. Then we have to fill in the
55598 * cast linked list. The cast data is initially stored in something like a
55599 * two-dimensional array. Each row corresponds to a type (there are the same
55600 * number of rows as there are in the swig_type_initial array). Each entry in
55601 * a column is one of the swig_cast_info structures for that type.
55602 * The cast_initial array is actually an array of arrays, because each row has
55603 * a variable number of columns. So to actually build the cast linked list,
55604 * we find the array of casts associated with the type, and loop through it
55605 * adding the casts to the list. The one last trick we need to do is making
55606 * sure the type pointer in the swig_cast_info struct is correct.
55607 *
55608 * First off, we lookup the cast->type name to see if it is already loaded.
55609 * There are three cases to handle:
55610 * 1) If the cast->type has already been loaded AND the type we are adding
55611 * casting info to has not been loaded (it is in this module), THEN we
55612 * replace the cast->type pointer with the type pointer that has already
55613 * been loaded.
55614 * 2) If BOTH types (the one we are adding casting info to, and the
55615 * cast->type) are loaded, THEN the cast info has already been loaded by
55616 * the previous module so we just ignore it.
55617 * 3) Finally, if cast->type has not already been loaded, then we add that
55618 * swig_cast_info to the linked list (because the cast->type) pointer will
55619 * be correct.
55620 * ----------------------------------------------------------------------------- */
55621
55622 #ifdef __cplusplus
55623 extern "C" {
55624 #if 0
55625 } /* c-mode */
55626 #endif
55627 #endif
55628
55629 #if 0
55630 #define SWIGRUNTIME_DEBUG
55631 #endif
55632
55633 SWIGRUNTIME void
55634 SWIG_InitializeModule(void *clientdata) {
55635 size_t i;
55636 swig_module_info *module_head;
55637 static int init_run = 0;
55638
55639 clientdata = clientdata;
55640
55641 if (init_run) return;
55642 init_run = 1;
55643
55644 /* Initialize the swig_module */
55645 swig_module.type_initial = swig_type_initial;
55646 swig_module.cast_initial = swig_cast_initial;
55647
55648 /* Try and load any already created modules */
55649 module_head = SWIG_GetModule(clientdata);
55650 if (module_head) {
55651 swig_module.next = module_head->next;
55652 module_head->next = &swig_module;
55653 } else {
55654 /* This is the first module loaded */
55655 swig_module.next = &swig_module;
55656 SWIG_SetModule(clientdata, &swig_module);
55657 }
55658
55659 /* Now work on filling in swig_module.types */
55660 #ifdef SWIGRUNTIME_DEBUG
55661 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55662 #endif
55663 for (i = 0; i < swig_module.size; ++i) {
55664 swig_type_info *type = 0;
55665 swig_type_info *ret;
55666 swig_cast_info *cast;
55667
55668 #ifdef SWIGRUNTIME_DEBUG
55669 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55670 #endif
55671
55672 /* if there is another module already loaded */
55673 if (swig_module.next != &swig_module) {
55674 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55675 }
55676 if (type) {
55677 /* Overwrite clientdata field */
55678 #ifdef SWIGRUNTIME_DEBUG
55679 printf("SWIG_InitializeModule: found type %s\n", type->name);
55680 #endif
55681 if (swig_module.type_initial[i]->clientdata) {
55682 type->clientdata = swig_module.type_initial[i]->clientdata;
55683 #ifdef SWIGRUNTIME_DEBUG
55684 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55685 #endif
55686 }
55687 } else {
55688 type = swig_module.type_initial[i];
55689 }
55690
55691 /* Insert casting types */
55692 cast = swig_module.cast_initial[i];
55693 while (cast->type) {
55694 /* Don't need to add information already in the list */
55695 ret = 0;
55696 #ifdef SWIGRUNTIME_DEBUG
55697 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55698 #endif
55699 if (swig_module.next != &swig_module) {
55700 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55701 #ifdef SWIGRUNTIME_DEBUG
55702 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55703 #endif
55704 }
55705 if (ret) {
55706 if (type == swig_module.type_initial[i]) {
55707 #ifdef SWIGRUNTIME_DEBUG
55708 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55709 #endif
55710 cast->type = ret;
55711 ret = 0;
55712 } else {
55713 /* Check for casting already in the list */
55714 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55715 #ifdef SWIGRUNTIME_DEBUG
55716 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55717 #endif
55718 if (!ocast) ret = 0;
55719 }
55720 }
55721
55722 if (!ret) {
55723 #ifdef SWIGRUNTIME_DEBUG
55724 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55725 #endif
55726 if (type->cast) {
55727 type->cast->prev = cast;
55728 cast->next = type->cast;
55729 }
55730 type->cast = cast;
55731 }
55732 cast++;
55733 }
55734 /* Set entry in modules->types array equal to the type */
55735 swig_module.types[i] = type;
55736 }
55737 swig_module.types[i] = 0;
55738
55739 #ifdef SWIGRUNTIME_DEBUG
55740 printf("**** SWIG_InitializeModule: Cast List ******\n");
55741 for (i = 0; i < swig_module.size; ++i) {
55742 int j = 0;
55743 swig_cast_info *cast = swig_module.cast_initial[i];
55744 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55745 while (cast->type) {
55746 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55747 cast++;
55748 ++j;
55749 }
55750 printf("---- Total casts: %d\n",j);
55751 }
55752 printf("**** SWIG_InitializeModule: Cast List ******\n");
55753 #endif
55754 }
55755
55756 /* This function will propagate the clientdata field of type to
55757 * any new swig_type_info structures that have been added into the list
55758 * of equivalent types. It is like calling
55759 * SWIG_TypeClientData(type, clientdata) a second time.
55760 */
55761 SWIGRUNTIME void
55762 SWIG_PropagateClientData(void) {
55763 size_t i;
55764 swig_cast_info *equiv;
55765 static int init_run = 0;
55766
55767 if (init_run) return;
55768 init_run = 1;
55769
55770 for (i = 0; i < swig_module.size; i++) {
55771 if (swig_module.types[i]->clientdata) {
55772 equiv = swig_module.types[i]->cast;
55773 while (equiv) {
55774 if (!equiv->converter) {
55775 if (equiv->type && !equiv->type->clientdata)
55776 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55777 }
55778 equiv = equiv->next;
55779 }
55780 }
55781 }
55782 }
55783
55784 #ifdef __cplusplus
55785 #if 0
55786 {
55787 /* c-mode */
55788 #endif
55789 }
55790 #endif
55791
55792
55793
55794 #ifdef __cplusplus
55795 extern "C" {
55796 #endif
55797
55798 /* Python-specific SWIG API */
55799 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55800 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55801 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55802
55803 /* -----------------------------------------------------------------------------
55804 * global variable support code.
55805 * ----------------------------------------------------------------------------- */
55806
55807 typedef struct swig_globalvar {
55808 char *name; /* Name of global variable */
55809 PyObject *(*get_attr)(void); /* Return the current value */
55810 int (*set_attr)(PyObject *); /* Set the value */
55811 struct swig_globalvar *next;
55812 } swig_globalvar;
55813
55814 typedef struct swig_varlinkobject {
55815 PyObject_HEAD
55816 swig_globalvar *vars;
55817 } swig_varlinkobject;
55818
55819 SWIGINTERN PyObject *
55820 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55821 return PyString_FromString("<Swig global variables>");
55822 }
55823
55824 SWIGINTERN PyObject *
55825 swig_varlink_str(swig_varlinkobject *v) {
55826 PyObject *str = PyString_FromString("(");
55827 swig_globalvar *var;
55828 for (var = v->vars; var; var=var->next) {
55829 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55830 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55831 }
55832 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55833 return str;
55834 }
55835
55836 SWIGINTERN int
55837 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55838 PyObject *str = swig_varlink_str(v);
55839 fprintf(fp,"Swig global variables ");
55840 fprintf(fp,"%s\n", PyString_AsString(str));
55841 Py_DECREF(str);
55842 return 0;
55843 }
55844
55845 SWIGINTERN void
55846 swig_varlink_dealloc(swig_varlinkobject *v) {
55847 swig_globalvar *var = v->vars;
55848 while (var) {
55849 swig_globalvar *n = var->next;
55850 free(var->name);
55851 free(var);
55852 var = n;
55853 }
55854 }
55855
55856 SWIGINTERN PyObject *
55857 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55858 PyObject *res = NULL;
55859 swig_globalvar *var = v->vars;
55860 while (var) {
55861 if (strcmp(var->name,n) == 0) {
55862 res = (*var->get_attr)();
55863 break;
55864 }
55865 var = var->next;
55866 }
55867 if (res == NULL && !PyErr_Occurred()) {
55868 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55869 }
55870 return res;
55871 }
55872
55873 SWIGINTERN int
55874 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55875 int res = 1;
55876 swig_globalvar *var = v->vars;
55877 while (var) {
55878 if (strcmp(var->name,n) == 0) {
55879 res = (*var->set_attr)(p);
55880 break;
55881 }
55882 var = var->next;
55883 }
55884 if (res == 1 && !PyErr_Occurred()) {
55885 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55886 }
55887 return res;
55888 }
55889
55890 SWIGINTERN PyTypeObject*
55891 swig_varlink_type(void) {
55892 static char varlink__doc__[] = "Swig var link object";
55893 static PyTypeObject varlink_type;
55894 static int type_init = 0;
55895 if (!type_init) {
55896 const PyTypeObject tmp
55897 = {
55898 PyObject_HEAD_INIT(NULL)
55899 0, /* Number of items in variable part (ob_size) */
55900 (char *)"swigvarlink", /* Type name (tp_name) */
55901 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55902 0, /* Itemsize (tp_itemsize) */
55903 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55904 (printfunc) swig_varlink_print, /* Print (tp_print) */
55905 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55906 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55907 0, /* tp_compare */
55908 (reprfunc) swig_varlink_repr, /* tp_repr */
55909 0, /* tp_as_number */
55910 0, /* tp_as_sequence */
55911 0, /* tp_as_mapping */
55912 0, /* tp_hash */
55913 0, /* tp_call */
55914 (reprfunc)swig_varlink_str, /* tp_str */
55915 0, /* tp_getattro */
55916 0, /* tp_setattro */
55917 0, /* tp_as_buffer */
55918 0, /* tp_flags */
55919 varlink__doc__, /* tp_doc */
55920 0, /* tp_traverse */
55921 0, /* tp_clear */
55922 0, /* tp_richcompare */
55923 0, /* tp_weaklistoffset */
55924 #if PY_VERSION_HEX >= 0x02020000
55925 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55926 #endif
55927 #if PY_VERSION_HEX >= 0x02030000
55928 0, /* tp_del */
55929 #endif
55930 #ifdef COUNT_ALLOCS
55931 0,0,0,0 /* tp_alloc -> tp_next */
55932 #endif
55933 };
55934 varlink_type = tmp;
55935 varlink_type.ob_type = &PyType_Type;
55936 type_init = 1;
55937 }
55938 return &varlink_type;
55939 }
55940
55941 /* Create a variable linking object for use later */
55942 SWIGINTERN PyObject *
55943 SWIG_Python_newvarlink(void) {
55944 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55945 if (result) {
55946 result->vars = 0;
55947 }
55948 return ((PyObject*) result);
55949 }
55950
55951 SWIGINTERN void
55952 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55953 swig_varlinkobject *v = (swig_varlinkobject *) p;
55954 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55955 if (gv) {
55956 size_t size = strlen(name)+1;
55957 gv->name = (char *)malloc(size);
55958 if (gv->name) {
55959 strncpy(gv->name,name,size);
55960 gv->get_attr = get_attr;
55961 gv->set_attr = set_attr;
55962 gv->next = v->vars;
55963 }
55964 }
55965 v->vars = gv;
55966 }
55967
55968 SWIGINTERN PyObject *
55969 SWIG_globals() {
55970 static PyObject *_SWIG_globals = 0;
55971 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55972 return _SWIG_globals;
55973 }
55974
55975 /* -----------------------------------------------------------------------------
55976 * constants/methods manipulation
55977 * ----------------------------------------------------------------------------- */
55978
55979 /* Install Constants */
55980 SWIGINTERN void
55981 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55982 PyObject *obj = 0;
55983 size_t i;
55984 for (i = 0; constants[i].type; ++i) {
55985 switch(constants[i].type) {
55986 case SWIG_PY_POINTER:
55987 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55988 break;
55989 case SWIG_PY_BINARY:
55990 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55991 break;
55992 default:
55993 obj = 0;
55994 break;
55995 }
55996 if (obj) {
55997 PyDict_SetItemString(d, constants[i].name, obj);
55998 Py_DECREF(obj);
55999 }
56000 }
56001 }
56002
56003 /* -----------------------------------------------------------------------------*/
56004 /* Fix SwigMethods to carry the callback ptrs when needed */
56005 /* -----------------------------------------------------------------------------*/
56006
56007 SWIGINTERN void
56008 SWIG_Python_FixMethods(PyMethodDef *methods,
56009 swig_const_info *const_table,
56010 swig_type_info **types,
56011 swig_type_info **types_initial) {
56012 size_t i;
56013 for (i = 0; methods[i].ml_name; ++i) {
56014 const char *c = methods[i].ml_doc;
56015 if (c && (c = strstr(c, "swig_ptr: "))) {
56016 int j;
56017 swig_const_info *ci = 0;
56018 const char *name = c + 10;
56019 for (j = 0; const_table[j].type; ++j) {
56020 if (strncmp(const_table[j].name, name,
56021 strlen(const_table[j].name)) == 0) {
56022 ci = &(const_table[j]);
56023 break;
56024 }
56025 }
56026 if (ci) {
56027 size_t shift = (ci->ptype) - types;
56028 swig_type_info *ty = types_initial[shift];
56029 size_t ldoc = (c - methods[i].ml_doc);
56030 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56031 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56032 if (ndoc) {
56033 char *buff = ndoc;
56034 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56035 if (ptr) {
56036 strncpy(buff, methods[i].ml_doc, ldoc);
56037 buff += ldoc;
56038 strncpy(buff, "swig_ptr: ", 10);
56039 buff += 10;
56040 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56041 methods[i].ml_doc = ndoc;
56042 }
56043 }
56044 }
56045 }
56046 }
56047 }
56048
56049 #ifdef __cplusplus
56050 }
56051 #endif
56052
56053 /* -----------------------------------------------------------------------------*
56054 * Partial Init method
56055 * -----------------------------------------------------------------------------*/
56056
56057 #ifdef __cplusplus
56058 extern "C"
56059 #endif
56060 SWIGEXPORT void SWIG_init(void) {
56061 PyObject *m, *d;
56062
56063 /* Fix SwigMethods to carry the callback ptrs when needed */
56064 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56065
56066 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56067 d = PyModule_GetDict(m);
56068
56069 SWIG_InitializeModule(0);
56070 SWIG_InstallConstants(d,swig_const_table);
56071
56072
56073
56074 #ifndef wxPyUSE_EXPORT
56075 // Make our API structure a CObject so other modules can import it
56076 // from this module.
56077 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56078 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56079 Py_XDECREF(cobj);
56080 #endif
56081
56082 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56083 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56084 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56085 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56086 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56087 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56088 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56089 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56090 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56091 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56092 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56093 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56094 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56095 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56096 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56097 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56098 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56099 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56100 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56101 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56102 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56103 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56104 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56105 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56106 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56107 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56108 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56109 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56110 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56111 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56112 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56113 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56114 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56115 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56116 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56117 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56118 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56119 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56120 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56121 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56122 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56123 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56124 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56125 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56126 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56127 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56128 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56129 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56130 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56131 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56132 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56133 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56134 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56135 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56136 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56137 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56138 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56139 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56140 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56141 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56142 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56143 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56144 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56145 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56146 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56147 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56148 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56149 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56150 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56151 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56152 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56153 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56154 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56155 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56156 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56157 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56158 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56159 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56160 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56161 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56162 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56163 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56164 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56165 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56166 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56167 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56168 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56169 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56170 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56171 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56172 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56173 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56174 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56175 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56176 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56177 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56178 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56179 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56180 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56181 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56182 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56183 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56184 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56185 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56186 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56187 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56188 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56189 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56190 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56191 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56192 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56193 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56194 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56195 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56196 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56197 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56198 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56199 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56200 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56201 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56202 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56203 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56204 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56205 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56206 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56207 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56208 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56209 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56210 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56211 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56212 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56213 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56214 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56215 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56216 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56217 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56218 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56219 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56220 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56221 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56222 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56223 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56224 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56225 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56226 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56227 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56228 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56229 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56230 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56231 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56232 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56233 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56234 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56235 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56236 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56237 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56238 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56239 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56240 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56241 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56242 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56243 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56244 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56245 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56246 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56247 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56248 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56249 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56250 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56251 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56252 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56253 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56254 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56255 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56256 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56257 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56258 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56259 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56260 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56261 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56262 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56263 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56264 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56265 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56266 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56267 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56268 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56269 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56270 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56271 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56272 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56273 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56274 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56275 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56276 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56277 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56278 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56279 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56280 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56281 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56282 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56283 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56284 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56285 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56286 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56287 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56288 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56289 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56290 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56291 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56292 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56293 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56294 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56295 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56296 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56297 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56298 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56299 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56300 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56301 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56302 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56303 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56304 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56305 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56306 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56307 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56308 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56309 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56310 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56311 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56312 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56313 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56314 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56315 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56316 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56317 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56318 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56319 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56320 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56321 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56322 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56323 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56324 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56325 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56326 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56327 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56328 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56329 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56330 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56331 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56332 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56333 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56334 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56335 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56336 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56337 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56338 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56339 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56340 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56341 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56342 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56343 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56344 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56345 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56346 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56347 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56348 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56349 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56350 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56351 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56352 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56353 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56354 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56355 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56356 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56357 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56358 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56359 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56360 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56361 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56362 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56363 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56364 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56365 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56366 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56367 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56368 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56369 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56370 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56371 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56372 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56373 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56374 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56375 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56376 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56377 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56378 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56379 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56380 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56381 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56382 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56383 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56384 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56385 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56386 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56387 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56388 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56389 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56390 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56391 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56392 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56393 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56394 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56395 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56396 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56397 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56398 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56399 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56400 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56401 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56402 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56403 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56404 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56405 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56406 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56407 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56408 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56409 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56410 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56411 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56412 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56413 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56414 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56415 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56416 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56417 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56418 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56419 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56420 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56421 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56422 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56423 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56424 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56425 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56426 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56427 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56428 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56429 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56430 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56431 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56432 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56433 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56434 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56435 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56436 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56437 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56438 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56439 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56440 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56441 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56442 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56443 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56444 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56445 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56446 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56447 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56448 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56449 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56450 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56451 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56452 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56453 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56454 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56455 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56456 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56457 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56458 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56459 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56460 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56461 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56462 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56463 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56464 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56465 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56466 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56467 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56468 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56469 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56470 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56471 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56472 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56473 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56474 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56475 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56476 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56477 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56478 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56479 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56480 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56481 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56482 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56483 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56484 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56485 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56486 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56487 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56488 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56489 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56490 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56491 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56492 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56493 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56494 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56495 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56496 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56497 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56498 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56499 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56500 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56501 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56502 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56503 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56505 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56506 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56507 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56508 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56509 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56510 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56511 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56512 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56513 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56514 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56515 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56516 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56517 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56518 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56519 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56520 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56521 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56522 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56523 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56524 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56525 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56526 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56527 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56528 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56529 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56530 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56531 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56532 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56533 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56534 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56535 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56536 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56537 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56538 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56539 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56540 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56541 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56542 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56543 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56544 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56545 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56546 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56547 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56548 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56549 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56550 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56551 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56552 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56553 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56554 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56555 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56556 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56557 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56558 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56559 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56560 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56561 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56562 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56563 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56564 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56565 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56566 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56567 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56568 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56569 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56570 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56571 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56572 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56573 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56574 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56575 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56576 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56577 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56578 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56579 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56580 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56581 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56582 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56583 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56584 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56585 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56586 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56587 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56588 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56589 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56590 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56591 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56592 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56593 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56594 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56595 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56596 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56597 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56598 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56599 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56600 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56601 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56602 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56603 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56604 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56605 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56606 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56607 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56608 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56609 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56610 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56611 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56612 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56613 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56614 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56615 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56616 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56617 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56618 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56619 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56620 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56621 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56622 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56623 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56624 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56625 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56626 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56627 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56628 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56629 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56630 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56631 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56632 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56633 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56634 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56635 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56636 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56637 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56638 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56639 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56640 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56641 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56642 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56643 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56644 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56645 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56646 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56647 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56648 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56649 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56650 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56651 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56652 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56653 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56654 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56655 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56656 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56657 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56658 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56659 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56660 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56661 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56662 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56663 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56664 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56665 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56666 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56667 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56668 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56669 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56670 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56671 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56672 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56673 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56674 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56675 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56676 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56677 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56678 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56679 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56680 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56681 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56682 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56683 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56684 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56685 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56686 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56687 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56688 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56689 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56690 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56691 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56692 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56693 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56694 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56695 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56696 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56697 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56698 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56699 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56700 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56701 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56702 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56703 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56704 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56705 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56706 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56707 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56708 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56709 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56710 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56711 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56712 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56713 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56714 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56715 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56716 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56717 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56718 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56719 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56720 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56721 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56722 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56723 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56724 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56725 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56726 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56727 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56728 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56729 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56730 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56731 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56732 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56733 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56734 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56735 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56736 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56737 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56738 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56739 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56740 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56741 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56742 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56743 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56744
56745 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56746
56747
56748 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56749
56750 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56751 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56752 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56753 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56754 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56755 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56756 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56757 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56758 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56759 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56760 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56761 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56762 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56763 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56764 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56765 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56766 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56767 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56768 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56769 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56770 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56771 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56772 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56773 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56774 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56775 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56776 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56777 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56778 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56779 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56780 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56781 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56782 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56783 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56784 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56785 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56786 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56787 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56788 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56789 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56790 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56791 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56792 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56793 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56794 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56795 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56796 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56797 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56798 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56799 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56800 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56801 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56802 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56803 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56804 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56805 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56806 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56807 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56808 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56809 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56810 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56811 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56812 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56813 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56814 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56815 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56816 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56817 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56818 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56819 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56820 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56821 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56822 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56823 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56824 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56825 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56826 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56827 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56828 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56829 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56830 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56831 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56832 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56833 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56834 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56835 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56836 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56837 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56838 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56839 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56840 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56841 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56842 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56843 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56844 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56845 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56846 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56847 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56848 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56849 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56850 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56851 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56852 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56853 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56854 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56855 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56856 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56857 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56858 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56859 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56860 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56861 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56862 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56863 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56864 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56865 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56866 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56867 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56868 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56869 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56870 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56871 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56872 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56873 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56874 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56875 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56876 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56877 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56878 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56879 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56880 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56881 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56882 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56883 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56884 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56885 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56886 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56887 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56888 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56889 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56890 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56891 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56892 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56893 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56894 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56895 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56896 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56897 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56898 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56899 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56900 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56901 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56902 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56903 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56904 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56905 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56906 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56907 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56908 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56909 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56910 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56911 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56912 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56913 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56914 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56915 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56916 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56917 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56918 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56919 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56920 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56921 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56922 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56923 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56924 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56925 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56926 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56927 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56928 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56929 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
56930 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56931 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56932 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56933 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56934 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56935 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56936 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56937 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56938 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56939 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56940 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56941 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56942 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56943 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56944 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56945 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56946 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56947 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56948 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56949 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56950 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56951 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56952 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56953 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56954 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56955 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56956 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56957 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56958 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56959 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56960 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56961 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56962
56963 // Initialize threading, some globals and such
56964 __wxPyPreStart(d);
56965
56966
56967 // Although these are defined in __version__ they need to be here too so
56968 // that an assert can be done to ensure that the wxPython and the wxWindows
56969 // versions match.
56970 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56971 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56972 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56973
56974 }
56975
wxWidgets (Impactor)